forked from organicmaps/organicmaps
[ios] default implementation of the iCloud sync feature
Signed-off-by: Kiryl Kaveryn <kirylkaveryn@gmail.com>
This commit is contained in:
parent
d0ec7bf149
commit
9a4fdfc1a6
15 changed files with 1785 additions and 3 deletions
|
|
@ -121,6 +121,7 @@ using namespace osm_auth_ios;
|
|||
}
|
||||
[self enableTTSForTheFirstTime];
|
||||
|
||||
[[CloudStorageManager shared] start];
|
||||
[[DeepLinkHandler shared] applicationDidFinishLaunching:launchOptions];
|
||||
// application:openUrl:options is called later for deep links if YES is returned.
|
||||
return YES;
|
||||
|
|
|
|||
|
|
@ -34,4 +34,7 @@ NS_SWIFT_NAME(Settings)
|
|||
+ (NSString *)donateUrl;
|
||||
+ (BOOL)isNY;
|
||||
|
||||
+ (BOOL)iCLoudSynchronizationEnabled;
|
||||
+ (void)setICLoudSynchronizationEnabled:(BOOL)iCLoudSyncEnabled;
|
||||
|
||||
@end
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ NSString * const kUDAutoNightModeOff = @"AutoNightModeOff";
|
|||
NSString * const kThemeMode = @"ThemeMode";
|
||||
NSString * const kSpotlightLocaleLanguageId = @"SpotlightLocaleLanguageId";
|
||||
NSString * const kUDTrackWarningAlertWasShown = @"TrackWarningAlertWasShown";
|
||||
NSString * const kiCLoudSynchronizationEnabledKey = @"iCLoudSynchronizationEnabled";
|
||||
} // namespace
|
||||
|
||||
@implementation MWMSettings
|
||||
|
|
@ -156,4 +157,14 @@ NSString * const kUDTrackWarningAlertWasShown = @"TrackWarningAlertWasShown";
|
|||
return settings::Get("NY", isNY) ? isNY : false;
|
||||
}
|
||||
|
||||
+ (BOOL)iCLoudSynchronizationEnabled
|
||||
{
|
||||
return [NSUserDefaults.standardUserDefaults boolForKey:kiCLoudSynchronizationEnabledKey];
|
||||
}
|
||||
|
||||
+ (void)setICLoudSynchronizationEnabled:(BOOL)iCLoudSyncEnabled
|
||||
{
|
||||
[NSUserDefaults.standardUserDefaults setBool:iCLoudSyncEnabled forKey:kiCLoudSynchronizationEnabledKey];
|
||||
[NSNotificationCenter.defaultCenter postNotificationName:NSNotification.iCloudSynchronizationDidChangeEnabledState object:nil];
|
||||
}
|
||||
@end
|
||||
|
|
|
|||
338
iphone/Maps/Core/iCloud/CloudStorageManager.swift
Normal file
338
iphone/Maps/Core/iCloud/CloudStorageManager.swift
Normal file
|
|
@ -0,0 +1,338 @@
|
|||
enum VoidResult {
|
||||
case success
|
||||
case failure(Error)
|
||||
}
|
||||
|
||||
enum WritingResult {
|
||||
case success
|
||||
case reloadCategoriesAtURLs([URL])
|
||||
case deleteCategoriesAtURLs([URL])
|
||||
case failure(Error)
|
||||
}
|
||||
|
||||
typealias VoidResultCompletionHandler = (VoidResult) -> Void
|
||||
typealias WritingResultCompletionHandler = (WritingResult) -> Void
|
||||
|
||||
// TODO: Remove this type and use custom UTTypeIdentifier that is registered into the Info.plist after updating to the iOS >= 14.0.
|
||||
struct FileType {
|
||||
let fileExtension: String
|
||||
let typeIdentifier: String
|
||||
}
|
||||
|
||||
extension FileType {
|
||||
static let kml = FileType(fileExtension: "kml", typeIdentifier: "com.google.earth.kml")
|
||||
}
|
||||
|
||||
let kTrashDirectoryName = ".Trash"
|
||||
private let kBookmarksDirectoryName = "bookmarks"
|
||||
private let kICloudSynchronizationDidChangeEnabledStateNotificationName = "iCloudSynchronizationDidChangeEnabledStateNotification"
|
||||
private let kUDDidFinishInitialCloudSynchronization = "kUDDidFinishInitialCloudSynchronization"
|
||||
|
||||
@objc @objcMembers final class CloudStorageManager: NSObject {
|
||||
|
||||
fileprivate struct Observation {
|
||||
weak var observer: AnyObject?
|
||||
var onErrorCompletionHandler: ((NSError?) -> Void)?
|
||||
}
|
||||
|
||||
let fileManager: FileManager
|
||||
private let localDirectoryMonitor: LocalDirectoryMonitor
|
||||
private let cloudDirectoryMonitor: CloudDirectoryMonitor
|
||||
private let settings: Settings.Type
|
||||
private let bookmarksManager: BookmarksManager
|
||||
private let synchronizationStateManager: SynchronizationStateManager
|
||||
private var fileWriter: SynchronizationFileWriter?
|
||||
private var observers = [ObjectIdentifier: CloudStorageManager.Observation]()
|
||||
private var synchronizationError: SynchronizationError? {
|
||||
didSet { notifyObserversOnSynchronizationError(synchronizationError) }
|
||||
}
|
||||
|
||||
static private var isInitialSynchronization: Bool {
|
||||
return !UserDefaults.standard.bool(forKey: kUDDidFinishInitialCloudSynchronization)
|
||||
}
|
||||
|
||||
static let shared: CloudStorageManager = {
|
||||
let fileManager = FileManager.default
|
||||
let fileType = FileType.kml
|
||||
let cloudDirectoryMonitor = iCloudDocumentsDirectoryMonitor(fileManager: fileManager, fileType: fileType)
|
||||
let synchronizationStateManager = DefaultSynchronizationStateManager(isInitialSynchronization: CloudStorageManager.isInitialSynchronization)
|
||||
do {
|
||||
let localDirectoryMonitor = try DefaultLocalDirectoryMonitor(fileManager: fileManager, directory: fileManager.bookmarksDirectoryUrl, fileType: fileType)
|
||||
let clodStorageManager = try CloudStorageManager(fileManager: fileManager,
|
||||
settings: Settings.self,
|
||||
bookmarksManager: BookmarksManager.shared(),
|
||||
cloudDirectoryMonitor: cloudDirectoryMonitor,
|
||||
localDirectoryMonitor: localDirectoryMonitor,
|
||||
synchronizationStateManager: synchronizationStateManager)
|
||||
return clodStorageManager
|
||||
} catch {
|
||||
fatalError("Failed to create shared iCloud storage manager with error: \(error)")
|
||||
}
|
||||
}()
|
||||
|
||||
// MARK: - Initialization
|
||||
init(fileManager: FileManager,
|
||||
settings: Settings.Type,
|
||||
bookmarksManager: BookmarksManager,
|
||||
cloudDirectoryMonitor: CloudDirectoryMonitor,
|
||||
localDirectoryMonitor: LocalDirectoryMonitor,
|
||||
synchronizationStateManager: SynchronizationStateManager) throws {
|
||||
guard fileManager === cloudDirectoryMonitor.fileManager, fileManager === localDirectoryMonitor.fileManager else {
|
||||
throw NSError(domain: "CloudStorageManger", code: 0, userInfo: [NSLocalizedDescriptionKey: "File managers should be the same."])
|
||||
}
|
||||
self.fileManager = fileManager
|
||||
self.settings = settings
|
||||
self.bookmarksManager = bookmarksManager
|
||||
self.cloudDirectoryMonitor = cloudDirectoryMonitor
|
||||
self.localDirectoryMonitor = localDirectoryMonitor
|
||||
self.synchronizationStateManager = synchronizationStateManager
|
||||
super.init()
|
||||
}
|
||||
|
||||
// MARK: - Public
|
||||
@objc func start() {
|
||||
subscribeToSettingsNotifications()
|
||||
subscribeToApplicationLifecycleNotifications()
|
||||
cloudDirectoryMonitor.delegate = self
|
||||
localDirectoryMonitor.delegate = self
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Private
|
||||
private extension CloudStorageManager {
|
||||
// MARK: - Synchronization Lifecycle
|
||||
func startSynchronization() {
|
||||
LOG(.debug, "Start synchronization...")
|
||||
switch cloudDirectoryMonitor.state {
|
||||
case .started:
|
||||
LOG(.debug, "Synchronization is already started")
|
||||
return
|
||||
case .paused:
|
||||
resumeSynchronization()
|
||||
case .stopped:
|
||||
cloudDirectoryMonitor.start { [weak self] result in
|
||||
guard let self else { return }
|
||||
switch result {
|
||||
case .failure(let error):
|
||||
self.stopSynchronization()
|
||||
self.processError(error)
|
||||
case .success(let cloudDirectoryUrl):
|
||||
self.localDirectoryMonitor.start { result in
|
||||
switch result {
|
||||
case .failure(let error):
|
||||
self.stopSynchronization()
|
||||
self.processError(error)
|
||||
case .success(let localDirectoryUrl):
|
||||
self.fileWriter = SynchronizationFileWriter(fileManager: self.fileManager,
|
||||
localDirectoryUrl: localDirectoryUrl,
|
||||
cloudDirectoryUrl: cloudDirectoryUrl)
|
||||
LOG(.debug, "Synchronization is started successfully")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func stopSynchronization() {
|
||||
LOG(.debug, "Stop synchronization")
|
||||
localDirectoryMonitor.stop()
|
||||
cloudDirectoryMonitor.stop()
|
||||
synchronizationError = nil
|
||||
fileWriter = nil
|
||||
synchronizationStateManager.resetState()
|
||||
}
|
||||
|
||||
func pauseSynchronization() {
|
||||
LOG(.debug, "Pause synchronization")
|
||||
localDirectoryMonitor.pause()
|
||||
cloudDirectoryMonitor.pause()
|
||||
}
|
||||
|
||||
func resumeSynchronization() {
|
||||
LOG(.debug, "Resume synchronization")
|
||||
localDirectoryMonitor.resume()
|
||||
cloudDirectoryMonitor.resume()
|
||||
}
|
||||
|
||||
// MARK: - App Lifecycle
|
||||
func subscribeToApplicationLifecycleNotifications() {
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(appWillEnterForeground), name: UIApplication.didBecomeActiveNotification, object: nil)
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
|
||||
}
|
||||
|
||||
func unsubscribeFromApplicationLifecycleNotifications() {
|
||||
NotificationCenter.default.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
|
||||
NotificationCenter.default.removeObserver(self, name: UIApplication.didEnterBackgroundNotification, object: nil)
|
||||
}
|
||||
|
||||
func subscribeToSettingsNotifications() {
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(didChangeEnabledState), name: NSNotification.iCloudSynchronizationDidChangeEnabledState, object: nil)
|
||||
}
|
||||
|
||||
@objc func appWillEnterForeground() {
|
||||
guard settings.iCLoudSynchronizationEnabled() else { return }
|
||||
startSynchronization()
|
||||
}
|
||||
|
||||
@objc func appDidEnterBackground() {
|
||||
guard settings.iCLoudSynchronizationEnabled() else { return }
|
||||
pauseSynchronization()
|
||||
}
|
||||
|
||||
@objc func didChangeEnabledState() {
|
||||
settings.iCLoudSynchronizationEnabled() ? startSynchronization() : stopSynchronization()
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - iCloudStorageManger + LocalDirectoryMonitorDelegate
|
||||
extension CloudStorageManager: LocalDirectoryMonitorDelegate {
|
||||
func didFinishGathering(contents: LocalContents) {
|
||||
let events = synchronizationStateManager.resolveEvent(.didFinishGatheringLocalContents(contents))
|
||||
processEvents(events)
|
||||
}
|
||||
|
||||
func didUpdate(contents: LocalContents) {
|
||||
let events = synchronizationStateManager.resolveEvent(.didUpdateLocalContents(contents))
|
||||
processEvents(events)
|
||||
}
|
||||
|
||||
func didReceiveLocalMonitorError(_ error: Error) {
|
||||
processError(error)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - iCloudStorageManger + CloudDirectoryMonitorDelegate
|
||||
extension CloudStorageManager: CloudDirectoryMonitorDelegate {
|
||||
func didFinishGathering(contents: CloudContents) {
|
||||
let events = synchronizationStateManager.resolveEvent(.didFinishGatheringCloudContents(contents))
|
||||
processEvents(events)
|
||||
}
|
||||
|
||||
func didUpdate(contents: CloudContents) {
|
||||
let events = synchronizationStateManager.resolveEvent(.didUpdateCloudContents(contents))
|
||||
processEvents(events)
|
||||
}
|
||||
|
||||
func didReceiveCloudMonitorError(_ error: Error) {
|
||||
processError(error)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Private methods
|
||||
private extension CloudStorageManager {
|
||||
func processEvents(_ events: [OutgoingEvent]) {
|
||||
guard !events.isEmpty else {
|
||||
synchronizationError = nil
|
||||
return
|
||||
}
|
||||
|
||||
LOG(.debug, "Start processing events...")
|
||||
events.forEach { [weak self] event in
|
||||
LOG(.debug, "Processing event: \(event)")
|
||||
guard let self, let fileWriter else { return }
|
||||
fileWriter.processEvent(event, completion: writingResultHandler(for: event))
|
||||
}
|
||||
}
|
||||
|
||||
func writingResultHandler(for event: OutgoingEvent) -> WritingResultCompletionHandler {
|
||||
return { [weak self] result in
|
||||
guard let self else { return }
|
||||
DispatchQueue.main.async {
|
||||
switch result {
|
||||
case .success:
|
||||
// Mark that initial synchronization is finished.
|
||||
if case .didFinishInitialSynchronization = event {
|
||||
UserDefaults.standard.set(true, forKey: kUDDidFinishInitialCloudSynchronization)
|
||||
}
|
||||
case .reloadCategoriesAtURLs(let urls):
|
||||
urls.forEach { self.bookmarksManager.reloadCategory(atFilePath: $0.path) }
|
||||
case .deleteCategoriesAtURLs(let urls):
|
||||
urls.forEach { self.bookmarksManager.deleteCategory(atFilePath: $0.path) }
|
||||
case .failure(let error):
|
||||
self.processError(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Error handling
|
||||
func processError(_ error: Error) {
|
||||
if let synchronizationError = error as? SynchronizationError {
|
||||
LOG(.debug, "Synchronization error: \(error.localizedDescription)")
|
||||
switch synchronizationError {
|
||||
case .fileUnavailable: break
|
||||
case .fileNotUploadedDueToQuota: break
|
||||
case .ubiquityServerNotAvailable: break
|
||||
case .iCloudIsNotAvailable: fallthrough
|
||||
case .failedToOpenLocalDirectoryFileDescriptor: fallthrough
|
||||
case .failedToRetrieveLocalDirectoryContent: fallthrough
|
||||
case .containerNotFound:
|
||||
stopSynchronization()
|
||||
}
|
||||
self.synchronizationError = synchronizationError
|
||||
} else {
|
||||
// TODO: Handle non-synchronization errors
|
||||
LOG(.debug, "Non-synchronization error: \(error.localizedDescription)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - CloudStorageManger Observing
|
||||
extension CloudStorageManager {
|
||||
func addObserver(_ observer: AnyObject, onErrorCompletionHandler: @escaping (NSError?) -> Void) {
|
||||
let id = ObjectIdentifier(observer)
|
||||
observers[id] = Observation(observer: observer, onErrorCompletionHandler:onErrorCompletionHandler)
|
||||
// Notify the new observer immediately to handle initial state.
|
||||
observers[id]?.onErrorCompletionHandler?(synchronizationError as NSError?)
|
||||
}
|
||||
|
||||
func removeObserver(_ observer: AnyObject) {
|
||||
let id = ObjectIdentifier(observer)
|
||||
observers.removeValue(forKey: id)
|
||||
}
|
||||
|
||||
private func notifyObserversOnSynchronizationError(_ error: SynchronizationError?) {
|
||||
self.observers.removeUnreachable().forEach { _, observable in
|
||||
DispatchQueue.main.async {
|
||||
observable.onErrorCompletionHandler?(error as NSError?)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - FileManager + Directories
|
||||
extension FileManager {
|
||||
var bookmarksDirectoryUrl: URL {
|
||||
urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent(kBookmarksDirectoryName, isDirectory: true)
|
||||
}
|
||||
|
||||
func trashDirectoryUrl(for baseDirectoryUrl: URL) throws -> URL {
|
||||
let trashDirectory = baseDirectoryUrl.appendingPathComponent(kTrashDirectoryName, isDirectory: true)
|
||||
if !fileExists(atPath: trashDirectory.path) {
|
||||
try createDirectory(at: trashDirectory, withIntermediateDirectories: true)
|
||||
}
|
||||
return trashDirectory
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Notification + iCloudSynchronizationDidChangeEnabledState
|
||||
extension Notification.Name {
|
||||
static let iCloudSynchronizationDidChangeEnabledStateNotification = Notification.Name(kICloudSynchronizationDidChangeEnabledStateNotificationName)
|
||||
}
|
||||
|
||||
@objc extension NSNotification {
|
||||
public static let iCloudSynchronizationDidChangeEnabledState = Notification.Name.iCloudSynchronizationDidChangeEnabledStateNotification
|
||||
}
|
||||
|
||||
// MARK: - Dictionary + RemoveUnreachable
|
||||
private extension Dictionary where Key == ObjectIdentifier, Value == CloudStorageManager.Observation {
|
||||
mutating func removeUnreachable() -> Self {
|
||||
for (id, observation) in self {
|
||||
if observation.observer == nil {
|
||||
removeValue(forKey: id)
|
||||
}
|
||||
}
|
||||
return self
|
||||
}
|
||||
}
|
||||
216
iphone/Maps/Core/iCloud/DefaultLocalDirectoryMonitor.swift
Normal file
216
iphone/Maps/Core/iCloud/DefaultLocalDirectoryMonitor.swift
Normal file
|
|
@ -0,0 +1,216 @@
|
|||
enum DirectoryMonitorState: CaseIterable, Equatable {
|
||||
case started
|
||||
case stopped
|
||||
case paused
|
||||
}
|
||||
|
||||
protocol DirectoryMonitor: AnyObject {
|
||||
var state: DirectoryMonitorState { get }
|
||||
|
||||
func start(completion: ((Result<URL, Error>) -> Void)?)
|
||||
func stop()
|
||||
func pause()
|
||||
func resume()
|
||||
}
|
||||
|
||||
protocol LocalDirectoryMonitor: DirectoryMonitor {
|
||||
var fileManager: FileManager { get }
|
||||
var directory: URL { get }
|
||||
var delegate: LocalDirectoryMonitorDelegate? { get set }
|
||||
}
|
||||
|
||||
protocol LocalDirectoryMonitorDelegate : AnyObject {
|
||||
func didFinishGathering(contents: LocalContents)
|
||||
func didUpdate(contents: LocalContents)
|
||||
func didReceiveLocalMonitorError(_ error: Error)
|
||||
}
|
||||
|
||||
final class DefaultLocalDirectoryMonitor: LocalDirectoryMonitor {
|
||||
|
||||
typealias Delegate = LocalDirectoryMonitorDelegate
|
||||
|
||||
fileprivate enum DispatchSourceDebounceState {
|
||||
case stopped
|
||||
case started(source: DispatchSourceFileSystemObject)
|
||||
case debounce(source: DispatchSourceFileSystemObject, timer: Timer)
|
||||
}
|
||||
|
||||
let fileManager: FileManager
|
||||
let fileType: FileType
|
||||
private let resourceKeys: [URLResourceKey] = [.nameKey]
|
||||
private var dispatchSource: DispatchSourceFileSystemObject?
|
||||
private var dispatchSourceDebounceState: DispatchSourceDebounceState = .stopped
|
||||
private var dispatchSourceIsSuspended = false
|
||||
private var dispatchSourceIsResumed = false
|
||||
private var didFinishGatheringIsCalled = false
|
||||
|
||||
// MARK: - Public properties
|
||||
let directory: URL
|
||||
private(set) var state: DirectoryMonitorState = .stopped
|
||||
weak var delegate: Delegate?
|
||||
|
||||
init(fileManager: FileManager, directory: URL, fileType: FileType = .kml) throws {
|
||||
self.fileManager = fileManager
|
||||
self.directory = directory
|
||||
self.fileType = fileType
|
||||
try fileManager.createDirectoryIfNeeded(at: directory)
|
||||
}
|
||||
|
||||
// MARK: - Public methods
|
||||
func start(completion: ((Result<URL, Error>) -> Void)? = nil) {
|
||||
guard state != .started else { return }
|
||||
|
||||
let nowTimer = Timer.scheduledTimer(withTimeInterval: .zero, repeats: false) { [weak self] _ in
|
||||
LOG(.debug, "LocalMonitor: Initial timer firing...")
|
||||
self?.debounceTimerDidFire()
|
||||
}
|
||||
|
||||
if let dispatchSource {
|
||||
dispatchSourceDebounceState = .debounce(source: dispatchSource, timer: nowTimer)
|
||||
resume()
|
||||
completion?(.success(directory))
|
||||
return
|
||||
}
|
||||
|
||||
do {
|
||||
let source = try fileManager.source(for: directory)
|
||||
source.setEventHandler { [weak self] in
|
||||
self?.queueDidFire()
|
||||
}
|
||||
dispatchSourceDebounceState = .debounce(source: source, timer: nowTimer)
|
||||
source.activate()
|
||||
dispatchSource = source
|
||||
state = .started
|
||||
completion?(.success(directory))
|
||||
} catch {
|
||||
stop()
|
||||
completion?(.failure(error))
|
||||
}
|
||||
}
|
||||
|
||||
func stop() {
|
||||
guard state == .started else { return }
|
||||
LOG(.debug, "LocalMonitor: Stop.")
|
||||
suspendDispatchSource()
|
||||
didFinishGatheringIsCalled = false
|
||||
dispatchSourceDebounceState = .stopped
|
||||
state = .stopped
|
||||
}
|
||||
|
||||
func pause() {
|
||||
guard state == .started else { return }
|
||||
LOG(.debug, "LocalMonitor: Pause.")
|
||||
suspendDispatchSource()
|
||||
state = .paused
|
||||
}
|
||||
|
||||
func resume() {
|
||||
guard state != .started else { return }
|
||||
LOG(.debug, "LocalMonitor: Resume.")
|
||||
resumeDispatchSource()
|
||||
state = .started
|
||||
}
|
||||
|
||||
// MARK: - Private
|
||||
private func queueDidFire() {
|
||||
LOG(.debug, "LocalMonitor: Queue did fire.")
|
||||
let debounceTimeInterval = 0.5
|
||||
switch dispatchSourceDebounceState {
|
||||
case .started(let source):
|
||||
let timer = Timer.scheduledTimer(withTimeInterval: debounceTimeInterval, repeats: false) { [weak self] _ in
|
||||
self?.debounceTimerDidFire()
|
||||
}
|
||||
dispatchSourceDebounceState = .debounce(source: source, timer: timer)
|
||||
case .debounce(_, let timer):
|
||||
timer.fireDate = Date(timeIntervalSinceNow: debounceTimeInterval)
|
||||
// Stay in the `.debounce` state.
|
||||
case .stopped:
|
||||
// This can happen if the read source fired and enqueued a block on the
|
||||
// main queue but, before the main queue got to service that block, someone
|
||||
// called `stop()`. The correct response is to just do nothing.
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
private func debounceTimerDidFire() {
|
||||
LOG(.debug, "LocalMonitor: Debounce timer did fire.")
|
||||
guard state == .started else {
|
||||
LOG(.debug, "LocalMonitor: State is not started. Skip iteration.")
|
||||
return
|
||||
}
|
||||
guard case .debounce(let source, let timer) = dispatchSourceDebounceState else { fatalError() }
|
||||
timer.invalidate()
|
||||
dispatchSourceDebounceState = .started(source: source)
|
||||
|
||||
do {
|
||||
let files = try fileManager.contentsOfDirectory(at: directory, includingPropertiesForKeys: [], options: [.skipsHiddenFiles], fileExtension: fileType.fileExtension)
|
||||
let contents = files.compactMap { url in
|
||||
do {
|
||||
let metadataItem = try LocalMetadataItem(fileUrl: url)
|
||||
return metadataItem
|
||||
} catch {
|
||||
delegate?.didReceiveLocalMonitorError(error)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
let contentMetadataItems = LocalContents(contents)
|
||||
|
||||
if !didFinishGatheringIsCalled {
|
||||
didFinishGatheringIsCalled = true
|
||||
LOG(.debug, "LocalMonitor: didFinishGathering called.")
|
||||
LOG(.debug, "LocalMonitor: contentMetadataItems count: \(contentMetadataItems.count)")
|
||||
delegate?.didFinishGathering(contents: contentMetadataItems)
|
||||
} else {
|
||||
LOG(.debug, "LocalMonitor: didUpdate called.")
|
||||
LOG(.debug, "LocalMonitor: contentMetadataItems count: \(contentMetadataItems.count)")
|
||||
delegate?.didUpdate(contents: contentMetadataItems)
|
||||
}
|
||||
} catch {
|
||||
LOG(.debug, "\(error)")
|
||||
delegate?.didReceiveLocalMonitorError(SynchronizationError.failedToRetrieveLocalDirectoryContent)
|
||||
}
|
||||
}
|
||||
|
||||
private func suspendDispatchSource() {
|
||||
if !dispatchSourceIsSuspended {
|
||||
LOG(.debug, "LocalMonitor: Suspend dispatch source.")
|
||||
dispatchSource?.suspend()
|
||||
dispatchSourceIsSuspended = true
|
||||
dispatchSourceIsResumed = false
|
||||
}
|
||||
}
|
||||
|
||||
private func resumeDispatchSource() {
|
||||
if !dispatchSourceIsResumed {
|
||||
LOG(.debug, "LocalMonitor: Resume dispatch source.")
|
||||
dispatchSource?.resume()
|
||||
dispatchSourceIsResumed = true
|
||||
dispatchSourceIsSuspended = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private extension FileManager {
|
||||
func source(for directory: URL) throws -> DispatchSourceFileSystemObject {
|
||||
let directoryFileDescriptor = open(directory.path, O_EVTONLY)
|
||||
guard directoryFileDescriptor >= 0 else {
|
||||
throw SynchronizationError.failedToOpenLocalDirectoryFileDescriptor
|
||||
}
|
||||
let dispatchSource = DispatchSource.makeFileSystemObjectSource(fileDescriptor: directoryFileDescriptor, eventMask: [.write], queue: DispatchQueue.main)
|
||||
dispatchSource.setCancelHandler {
|
||||
close(directoryFileDescriptor)
|
||||
}
|
||||
return dispatchSource
|
||||
}
|
||||
|
||||
func createDirectoryIfNeeded(at url: URL) throws {
|
||||
if !fileExists(atPath: url.path) {
|
||||
try createDirectory(at: url, withIntermediateDirectories: true)
|
||||
}
|
||||
}
|
||||
|
||||
func contentsOfDirectory(at url: URL, includingPropertiesForKeys keys: [URLResourceKey]?, options: FileManager.DirectoryEnumerationOptions, fileExtension: String) throws -> [URL] {
|
||||
let files = try contentsOfDirectory(at: url, includingPropertiesForKeys: keys, options: options)
|
||||
return files.filter { $0.pathExtension == fileExtension }
|
||||
}
|
||||
}
|
||||
156
iphone/Maps/Core/iCloud/MetadataItem.swift
Normal file
156
iphone/Maps/Core/iCloud/MetadataItem.swift
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
protocol MetadataItem: Equatable, Hashable {
|
||||
var fileName: String { get }
|
||||
var fileUrl: URL { get }
|
||||
var fileSize: Int { get }
|
||||
var contentType: String { get }
|
||||
var creationDate: TimeInterval { get }
|
||||
var lastModificationDate: TimeInterval { get }
|
||||
}
|
||||
|
||||
struct LocalMetadataItem: MetadataItem {
|
||||
let fileName: String
|
||||
let fileUrl: URL
|
||||
let fileSize: Int
|
||||
let contentType: String
|
||||
let creationDate: TimeInterval
|
||||
let lastModificationDate: TimeInterval
|
||||
}
|
||||
|
||||
struct CloudMetadataItem: MetadataItem {
|
||||
let fileName: String
|
||||
let fileUrl: URL
|
||||
let fileSize: Int
|
||||
let contentType: String
|
||||
var isDownloaded: Bool
|
||||
let creationDate: TimeInterval
|
||||
var lastModificationDate: TimeInterval
|
||||
var isRemoved: Bool
|
||||
let downloadingError: NSError?
|
||||
let uploadingError: NSError?
|
||||
let hasUnresolvedConflicts: Bool
|
||||
}
|
||||
|
||||
extension LocalMetadataItem {
|
||||
init(metadataItem: NSMetadataItem) throws {
|
||||
guard let fileName = metadataItem.value(forAttribute: NSMetadataItemFSNameKey) as? String,
|
||||
let fileUrl = metadataItem.value(forAttribute: NSMetadataItemURLKey) as? URL,
|
||||
let fileSize = metadataItem.value(forAttribute: NSMetadataItemFSSizeKey) as? Int,
|
||||
let contentType = metadataItem.value(forAttribute: NSMetadataItemContentTypeKey) as? String,
|
||||
let creationDate = (metadataItem.value(forAttribute: NSMetadataItemFSCreationDateKey) as? Date)?.timeIntervalSince1970.rounded(.down),
|
||||
let lastModificationDate = (metadataItem.value(forAttribute: NSMetadataItemFSContentChangeDateKey) as? Date)?.timeIntervalSince1970.rounded(.down) else {
|
||||
throw NSError(domain: "LocalMetadataItem", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize LocalMetadataItem from NSMetadataItem"])
|
||||
}
|
||||
self.fileName = fileName
|
||||
self.fileUrl = fileUrl
|
||||
self.fileSize = fileSize
|
||||
self.contentType = contentType
|
||||
self.creationDate = creationDate
|
||||
self.lastModificationDate = lastModificationDate
|
||||
}
|
||||
|
||||
init(fileUrl: URL) throws {
|
||||
let resources = try fileUrl.resourceValues(forKeys: [.fileSizeKey, .typeIdentifierKey, .contentModificationDateKey, .creationDateKey])
|
||||
guard let fileSize = resources.fileSize,
|
||||
let contentType = resources.typeIdentifier,
|
||||
let creationDate = resources.creationDate?.timeIntervalSince1970.rounded(.down),
|
||||
let lastModificationDate = resources.contentModificationDate?.timeIntervalSince1970.rounded(.down) else {
|
||||
throw NSError(domain: "LocalMetadataItem", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize LocalMetadataItem from URL"])
|
||||
}
|
||||
self.fileName = fileUrl.lastPathComponent
|
||||
self.fileUrl = fileUrl
|
||||
self.fileSize = fileSize
|
||||
self.contentType = contentType
|
||||
self.creationDate = creationDate
|
||||
self.lastModificationDate = lastModificationDate
|
||||
}
|
||||
|
||||
func fileData() throws -> Data {
|
||||
try Data(contentsOf: fileUrl)
|
||||
}
|
||||
}
|
||||
|
||||
extension CloudMetadataItem {
|
||||
init(metadataItem: NSMetadataItem) throws {
|
||||
guard let fileName = metadataItem.value(forAttribute: NSMetadataItemFSNameKey) as? String,
|
||||
let fileUrl = metadataItem.value(forAttribute: NSMetadataItemURLKey) as? URL,
|
||||
let fileSize = metadataItem.value(forAttribute: NSMetadataItemFSSizeKey) as? Int,
|
||||
let contentType = metadataItem.value(forAttribute: NSMetadataItemContentTypeKey) as? String,
|
||||
let downloadStatus = metadataItem.value(forAttribute: NSMetadataUbiquitousItemDownloadingStatusKey) as? String,
|
||||
let creationDate = (metadataItem.value(forAttribute: NSMetadataItemFSCreationDateKey) as? Date)?.timeIntervalSince1970.rounded(.down),
|
||||
let lastModificationDate = (metadataItem.value(forAttribute: NSMetadataItemFSContentChangeDateKey) as? Date)?.timeIntervalSince1970.rounded(.down),
|
||||
let hasUnresolvedConflicts = metadataItem.value(forAttribute: NSMetadataUbiquitousItemHasUnresolvedConflictsKey) as? Bool else {
|
||||
throw NSError(domain: "CloudMetadataItem", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize CloudMetadataItem from NSMetadataItem"])
|
||||
}
|
||||
self.fileName = fileName
|
||||
self.fileUrl = fileUrl
|
||||
self.fileSize = fileSize
|
||||
self.contentType = contentType
|
||||
self.isDownloaded = downloadStatus == NSMetadataUbiquitousItemDownloadingStatusCurrent
|
||||
self.creationDate = creationDate
|
||||
self.lastModificationDate = lastModificationDate
|
||||
self.isRemoved = CloudMetadataItem.isInTrash(fileUrl)
|
||||
self.hasUnresolvedConflicts = hasUnresolvedConflicts
|
||||
self.downloadingError = metadataItem.value(forAttribute: NSMetadataUbiquitousItemDownloadingErrorKey) as? NSError
|
||||
self.uploadingError = metadataItem.value(forAttribute: NSMetadataUbiquitousItemUploadingErrorKey) as? NSError
|
||||
}
|
||||
|
||||
init(fileUrl: URL) throws {
|
||||
let resources = try fileUrl.resourceValues(forKeys: [.nameKey, .fileSizeKey, .typeIdentifierKey, .contentModificationDateKey, .creationDateKey, .ubiquitousItemDownloadingStatusKey, .ubiquitousItemHasUnresolvedConflictsKey, .ubiquitousItemDownloadingErrorKey, .ubiquitousItemUploadingErrorKey])
|
||||
guard let fileSize = resources.fileSize,
|
||||
let contentType = resources.typeIdentifier,
|
||||
let creationDate = resources.creationDate?.timeIntervalSince1970.rounded(.down),
|
||||
let downloadStatus = resources.ubiquitousItemDownloadingStatus,
|
||||
let lastModificationDate = resources.contentModificationDate?.timeIntervalSince1970.rounded(.down),
|
||||
let hasUnresolvedConflicts = resources.ubiquitousItemHasUnresolvedConflicts else {
|
||||
throw NSError(domain: "CloudMetadataItem", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize CloudMetadataItem from NSMetadataItem"])
|
||||
}
|
||||
self.fileName = fileUrl.lastPathComponent
|
||||
self.fileUrl = fileUrl
|
||||
self.fileSize = fileSize
|
||||
self.contentType = contentType
|
||||
self.isDownloaded = downloadStatus.rawValue == NSMetadataUbiquitousItemDownloadingStatusCurrent
|
||||
self.creationDate = creationDate
|
||||
self.lastModificationDate = lastModificationDate
|
||||
self.isRemoved = CloudMetadataItem.isInTrash(fileUrl)
|
||||
self.hasUnresolvedConflicts = hasUnresolvedConflicts
|
||||
self.downloadingError = resources.ubiquitousItemDownloadingError
|
||||
self.uploadingError = resources.ubiquitousItemUploadingError
|
||||
}
|
||||
|
||||
static func isInTrash(_ fileUrl: URL) -> Bool {
|
||||
fileUrl.pathComponents.contains(kTrashDirectoryName)
|
||||
}
|
||||
|
||||
func relatedLocalItemUrl(to localContainer: URL) -> URL {
|
||||
localContainer.appendingPathComponent(fileName)
|
||||
}
|
||||
}
|
||||
|
||||
extension LocalMetadataItem {
|
||||
func relatedCloudItemUrl(to cloudContainer: URL) -> URL {
|
||||
cloudContainer.appendingPathComponent(fileName)
|
||||
}
|
||||
}
|
||||
|
||||
extension Array where Element: MetadataItem {
|
||||
func containsByName(_ item: any MetadataItem) -> Bool {
|
||||
return contains(where: { $0.fileName == item.fileName })
|
||||
}
|
||||
func firstByName(_ item: any MetadataItem) -> Element? {
|
||||
return first(where: { $0.fileName == item.fileName })
|
||||
}
|
||||
}
|
||||
|
||||
extension Array where Element == CloudMetadataItem {
|
||||
var downloaded: Self {
|
||||
filter { $0.isDownloaded }
|
||||
}
|
||||
|
||||
var notDownloaded: Self {
|
||||
filter { !$0.isDownloaded }
|
||||
}
|
||||
|
||||
func withUnresolvedConflicts(_ hasUnresolvedConflicts: Bool) -> Self {
|
||||
filter { $0.hasUnresolvedConflicts == hasUnresolvedConflicts }
|
||||
}
|
||||
}
|
||||
45
iphone/Maps/Core/iCloud/SynchronizationError.swift
Normal file
45
iphone/Maps/Core/iCloud/SynchronizationError.swift
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
@objc enum SynchronizationError: Int, Error {
|
||||
case fileUnavailable
|
||||
case fileNotUploadedDueToQuota
|
||||
case ubiquityServerNotAvailable
|
||||
case iCloudIsNotAvailable
|
||||
case containerNotFound
|
||||
case failedToOpenLocalDirectoryFileDescriptor
|
||||
case failedToRetrieveLocalDirectoryContent
|
||||
}
|
||||
|
||||
extension SynchronizationError: LocalizedError {
|
||||
var errorDescription: String? {
|
||||
switch self {
|
||||
case .fileUnavailable, .ubiquityServerNotAvailable:
|
||||
return L("icloud_synchronization_error_connection_error")
|
||||
case .fileNotUploadedDueToQuota:
|
||||
return L("icloud_synchronization_error_quota_exceeded")
|
||||
case .iCloudIsNotAvailable, .containerNotFound:
|
||||
return L("icloud_synchronization_error_cloud_is_unavailable")
|
||||
case .failedToOpenLocalDirectoryFileDescriptor:
|
||||
return "Failed to open local directory file descriptor"
|
||||
case .failedToRetrieveLocalDirectoryContent:
|
||||
return "Failed to retrieve local directory content"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension SynchronizationError {
|
||||
static func fromError(_ error: Error) -> SynchronizationError? {
|
||||
let nsError = error as NSError
|
||||
switch nsError.code {
|
||||
// NSURLUbiquitousItemDownloadingErrorKey contains an error with this code when the item has not been uploaded to iCloud by the other devices yet
|
||||
case NSUbiquitousFileUnavailableError:
|
||||
return .fileUnavailable
|
||||
// NSURLUbiquitousItemUploadingErrorKey contains an error with this code when the item has not been uploaded to iCloud because it would make the account go over-quota
|
||||
case NSUbiquitousFileNotUploadedDueToQuotaError:
|
||||
return .fileNotUploadedDueToQuota
|
||||
// NSURLUbiquitousItemDownloadingErrorKey and NSURLUbiquitousItemUploadingErrorKey contain an error with this code when connecting to the iCloud servers failed
|
||||
case NSUbiquitousFileUbiquityServerNotAvailable:
|
||||
return .ubiquityServerNotAvailable
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
273
iphone/Maps/Core/iCloud/SynchronizationFileWriter.swift
Normal file
273
iphone/Maps/Core/iCloud/SynchronizationFileWriter.swift
Normal file
|
|
@ -0,0 +1,273 @@
|
|||
final class SynchronizationFileWriter {
|
||||
private let fileManager: FileManager
|
||||
private let backgroundQueue = DispatchQueue(label: "iCloud.app.organicmaps.backgroundQueue", qos: .background)
|
||||
private let fileCoordinator: NSFileCoordinator
|
||||
private let localDirectoryUrl: URL
|
||||
private let cloudDirectoryUrl: URL
|
||||
|
||||
init(fileManager: FileManager = .default,
|
||||
fileCoordinator: NSFileCoordinator = NSFileCoordinator(),
|
||||
localDirectoryUrl: URL,
|
||||
cloudDirectoryUrl: URL) {
|
||||
self.fileManager = fileManager
|
||||
self.fileCoordinator = fileCoordinator
|
||||
self.localDirectoryUrl = localDirectoryUrl
|
||||
self.cloudDirectoryUrl = cloudDirectoryUrl
|
||||
}
|
||||
|
||||
func processEvent(_ event: OutgoingEvent, completion: @escaping WritingResultCompletionHandler) {
|
||||
backgroundQueue.async { [weak self] in
|
||||
guard let self else { return }
|
||||
switch event {
|
||||
case .createLocalItem(let cloudMetadataItem): self.createInLocalContainer(cloudMetadataItem, completion: completion)
|
||||
case .updateLocalItem(let cloudMetadataItem): self.updateInLocalContainer(cloudMetadataItem, completion: completion)
|
||||
case .removeLocalItem(let cloudMetadataItem): self.removeFromLocalContainer(cloudMetadataItem, completion: completion)
|
||||
case .startDownloading(let cloudMetadataItem): self.startDownloading(cloudMetadataItem, completion: completion)
|
||||
case .createCloudItem(let localMetadataItem): self.createInCloudContainer(localMetadataItem, completion: completion)
|
||||
case .updateCloudItem(let localMetadataItem): self.updateInCloudContainer(localMetadataItem, completion: completion)
|
||||
case .removeCloudItem(let localMetadataItem): self.removeFromCloudContainer(localMetadataItem, completion: completion)
|
||||
case .resolveVersionsConflict(let cloudMetadataItem): self.resolveVersionsConflict(cloudMetadataItem, completion: completion)
|
||||
case .resolveInitialSynchronizationConflict(let localMetadataItem): self.resolveInitialSynchronizationConflict(localMetadataItem, completion: completion)
|
||||
case .didFinishInitialSynchronization: completion(.success)
|
||||
case .didReceiveError(let error): completion(.failure(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Read/Write/Downloading/Uploading
|
||||
private func startDownloading(_ cloudMetadataItem: CloudMetadataItem, completion: WritingResultCompletionHandler) {
|
||||
do {
|
||||
LOG(.debug, "Start downloading file: \(cloudMetadataItem.fileName)...")
|
||||
try fileManager.startDownloadingUbiquitousItem(at: cloudMetadataItem.fileUrl)
|
||||
completion(.success)
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
}
|
||||
}
|
||||
|
||||
private func createInLocalContainer(_ cloudMetadataItem: CloudMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
let targetLocalFileUrl = cloudMetadataItem.relatedLocalItemUrl(to: localDirectoryUrl)
|
||||
guard !fileManager.fileExists(atPath: targetLocalFileUrl.path) else {
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) already exists in the local iCloud container.")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
writeToLocalContainer(cloudMetadataItem, completion: completion)
|
||||
}
|
||||
|
||||
private func updateInLocalContainer(_ cloudMetadataItem: CloudMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
writeToLocalContainer(cloudMetadataItem, completion: completion)
|
||||
}
|
||||
|
||||
private func writeToLocalContainer(_ cloudMetadataItem: CloudMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
var coordinationError: NSError?
|
||||
let targetLocalFileUrl = cloudMetadataItem.relatedLocalItemUrl(to: localDirectoryUrl)
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) is downloaded to the local iCloud container. Start coordinating and writing file...")
|
||||
fileCoordinator.coordinate(readingItemAt: cloudMetadataItem.fileUrl, writingItemAt: targetLocalFileUrl, error: &coordinationError) { readingUrl, writingUrl in
|
||||
do {
|
||||
let cloudFileData = try Data(contentsOf: readingUrl)
|
||||
try cloudFileData.write(to: writingUrl, options: .atomic, lastModificationDate: cloudMetadataItem.lastModificationDate)
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) is copied to local directory successfully. Start reloading bookmarks...")
|
||||
completion(.reloadCategoriesAtURLs([writingUrl]))
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
}
|
||||
return
|
||||
}
|
||||
if let coordinationError {
|
||||
completion(.failure(coordinationError))
|
||||
}
|
||||
}
|
||||
|
||||
private func removeFromLocalContainer(_ cloudMetadataItem: CloudMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
LOG(.debug, "Start removing file \(cloudMetadataItem.fileName) from the local directory...")
|
||||
let targetLocalFileUrl = cloudMetadataItem.relatedLocalItemUrl(to: localDirectoryUrl)
|
||||
guard fileManager.fileExists(atPath: targetLocalFileUrl.path) else {
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) doesn't exist in the local directory and cannot be removed.")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
completion(.deleteCategoriesAtURLs([targetLocalFileUrl]))
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) is removed from the local directory successfully.")
|
||||
}
|
||||
|
||||
private func createInCloudContainer(_ localMetadataItem: LocalMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
let targetCloudFileUrl = localMetadataItem.relatedCloudItemUrl(to: cloudDirectoryUrl)
|
||||
guard !fileManager.fileExists(atPath: targetCloudFileUrl.path) else {
|
||||
LOG(.debug, "File \(localMetadataItem.fileName) already exists in the cloud directory.")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
writeToCloudContainer(localMetadataItem, completion: completion)
|
||||
}
|
||||
|
||||
private func updateInCloudContainer(_ localMetadataItem: LocalMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
writeToCloudContainer(localMetadataItem, completion: completion)
|
||||
}
|
||||
|
||||
private func writeToCloudContainer(_ localMetadataItem: LocalMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
LOG(.debug, "Start writing file \(localMetadataItem.fileName) to the cloud directory...")
|
||||
let targetCloudFileUrl = localMetadataItem.relatedCloudItemUrl(to: cloudDirectoryUrl)
|
||||
var coordinationError: NSError?
|
||||
fileCoordinator.coordinate(readingItemAt: localMetadataItem.fileUrl, writingItemAt: targetCloudFileUrl, error: &coordinationError) { readingUrl, writingUrl in
|
||||
do {
|
||||
let fileData = try localMetadataItem.fileData()
|
||||
try fileData.write(to: writingUrl, lastModificationDate: localMetadataItem.lastModificationDate)
|
||||
LOG(.debug, "File \(localMetadataItem.fileName) is copied to the cloud directory successfully.")
|
||||
completion(.success)
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
}
|
||||
return
|
||||
}
|
||||
if let coordinationError {
|
||||
completion(.failure(coordinationError))
|
||||
}
|
||||
}
|
||||
|
||||
private func removeFromCloudContainer(_ localMetadataItem: LocalMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
LOG(.debug, "Start trashing file \(localMetadataItem.fileName)...")
|
||||
do {
|
||||
let targetCloudFileUrl = localMetadataItem.relatedCloudItemUrl(to: cloudDirectoryUrl)
|
||||
try removeDuplicatedFileFromTrashDirectoryIfNeeded(cloudDirectoryUrl: cloudDirectoryUrl, fileName: localMetadataItem.fileName)
|
||||
try self.fileManager.trashItem(at: targetCloudFileUrl, resultingItemURL: nil)
|
||||
LOG(.debug, "File \(localMetadataItem.fileName) was trashed successfully.")
|
||||
completion(.success)
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
}
|
||||
}
|
||||
|
||||
// Remove duplicated file from iCloud's .Trash directory if needed.
|
||||
// It's important to avoid the duplicating of names in the trash because we can't control the name of the trashed item.
|
||||
private func removeDuplicatedFileFromTrashDirectoryIfNeeded(cloudDirectoryUrl: URL, fileName: String) throws {
|
||||
// There are no ways to retrieve the content of iCloud's .Trash directory on macOS.
|
||||
if #available(iOS 14.0, *), ProcessInfo.processInfo.isiOSAppOnMac {
|
||||
return
|
||||
}
|
||||
LOG(.debug, "Checking if the file \(fileName) is already in the trash directory...")
|
||||
let trashDirectoryUrl = try fileManager.trashDirectoryUrl(for: cloudDirectoryUrl)
|
||||
let fileInTrashDirectoryUrl = trashDirectoryUrl.appendingPathComponent(fileName)
|
||||
let trashDirectoryContent = try fileManager.contentsOfDirectory(at: trashDirectoryUrl,
|
||||
includingPropertiesForKeys: [],
|
||||
options: [.skipsPackageDescendants, .skipsSubdirectoryDescendants])
|
||||
if trashDirectoryContent.contains(fileInTrashDirectoryUrl) {
|
||||
LOG(.debug, "File \(fileName) is already in the trash directory. Removing it...")
|
||||
try fileManager.removeItem(at: fileInTrashDirectoryUrl)
|
||||
LOG(.debug, "File \(fileName) was removed from the trash directory successfully.")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Merge conflicts resolving
|
||||
private func resolveVersionsConflict(_ cloudMetadataItem: CloudMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
LOG(.debug, "Start resolving version conflict for file \(cloudMetadataItem.fileName)...")
|
||||
|
||||
guard let versionsInConflict = NSFileVersion.unresolvedConflictVersionsOfItem(at: cloudMetadataItem.fileUrl), !versionsInConflict.isEmpty,
|
||||
let currentVersion = NSFileVersion.currentVersionOfItem(at: cloudMetadataItem.fileUrl) else {
|
||||
LOG(.debug, "No versions in conflict found for file \(cloudMetadataItem.fileName).")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
|
||||
let sortedVersions = versionsInConflict.sorted { version1, version2 in
|
||||
guard let date1 = version1.modificationDate, let date2 = version2.modificationDate else {
|
||||
return false
|
||||
}
|
||||
return date1 > date2
|
||||
}
|
||||
|
||||
guard let latestVersionInConflict = sortedVersions.first else {
|
||||
LOG(.debug, "No latest version in conflict found for file \(cloudMetadataItem.fileName).")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
|
||||
let targetCloudFileCopyUrl = generateNewFileUrl(for: cloudMetadataItem.fileUrl)
|
||||
var coordinationError: NSError?
|
||||
fileCoordinator.coordinate(writingItemAt: currentVersion.url,
|
||||
options: [.forReplacing],
|
||||
writingItemAt: targetCloudFileCopyUrl,
|
||||
options: [],
|
||||
error: &coordinationError) { currentVersionUrl, copyVersionUrl in
|
||||
// Check that during the coordination block, the current version of the file have not been already resolved by another process.
|
||||
guard let unresolvedVersions = NSFileVersion.unresolvedConflictVersionsOfItem(at: currentVersionUrl), !unresolvedVersions.isEmpty else {
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) was already resolved.")
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
do {
|
||||
// Check if the file was already resolved by another process. The in-memory versions should be marked as resolved.
|
||||
guard !fileManager.fileExists(atPath: copyVersionUrl.path) else {
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) was already resolved.")
|
||||
try NSFileVersion.removeOtherVersionsOfItem(at: currentVersionUrl)
|
||||
completion(.success)
|
||||
return
|
||||
}
|
||||
|
||||
LOG(.debug, "Duplicate file \(cloudMetadataItem.fileName)...")
|
||||
try latestVersionInConflict.replaceItem(at: copyVersionUrl)
|
||||
// The modification date should be updated to mark files that was involved into the resolving process.
|
||||
try currentVersionUrl.setResourceModificationDate(Date())
|
||||
try copyVersionUrl.setResourceModificationDate(Date())
|
||||
unresolvedVersions.forEach { $0.isResolved = true }
|
||||
try NSFileVersion.removeOtherVersionsOfItem(at: currentVersionUrl)
|
||||
LOG(.debug, "File \(cloudMetadataItem.fileName) was successfully resolved.")
|
||||
completion(.success)
|
||||
return
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if let coordinationError {
|
||||
completion(.failure(coordinationError))
|
||||
}
|
||||
}
|
||||
|
||||
private func resolveInitialSynchronizationConflict(_ localMetadataItem: LocalMetadataItem, completion: @escaping WritingResultCompletionHandler) {
|
||||
LOG(.debug, "Start resolving initial sync conflict for file \(localMetadataItem.fileName) by copying with a new name...")
|
||||
do {
|
||||
let newFileUrl = generateNewFileUrl(for: localMetadataItem.fileUrl, addDeviceName: true)
|
||||
try fileManager.copyItem(at: localMetadataItem.fileUrl, to: newFileUrl)
|
||||
LOG(.debug, "File \(localMetadataItem.fileName) was successfully resolved.")
|
||||
completion(.reloadCategoriesAtURLs([newFileUrl]))
|
||||
} catch {
|
||||
completion(.failure(error))
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Helper methods
|
||||
// Generate a new file URL with a new name for the file with the same name.
|
||||
// This method should generate the same name for the same file on different devices during the simultaneous conflict resolving.
|
||||
private func generateNewFileUrl(for fileUrl: URL, addDeviceName: Bool = false) -> URL {
|
||||
let baseName = fileUrl.deletingPathExtension().lastPathComponent
|
||||
let fileExtension = fileUrl.pathExtension
|
||||
let newBaseName = baseName + "_1"
|
||||
let deviceName = addDeviceName ? "_\(UIDevice.current.name)" : ""
|
||||
let newFileName = newBaseName + deviceName + "." + fileExtension
|
||||
let newFileUrl = fileUrl.deletingLastPathComponent().appendingPathComponent(newFileName)
|
||||
return newFileUrl
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - URL + ResourceValues
|
||||
private extension URL {
|
||||
func setResourceModificationDate(_ date: Date) throws {
|
||||
var url = self
|
||||
var resource = try resourceValues(forKeys:[.contentModificationDateKey])
|
||||
resource.contentModificationDate = date
|
||||
try url.setResourceValues(resource)
|
||||
}
|
||||
}
|
||||
|
||||
private extension Data {
|
||||
func write(to url: URL, options: Data.WritingOptions = .atomic, lastModificationDate: TimeInterval? = nil) throws {
|
||||
var url = url
|
||||
try write(to: url, options: options)
|
||||
if let lastModificationDate {
|
||||
try url.setResourceModificationDate(Date(timeIntervalSince1970: lastModificationDate))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
260
iphone/Maps/Core/iCloud/SynchronizationStateManager.swift
Normal file
260
iphone/Maps/Core/iCloud/SynchronizationStateManager.swift
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
typealias MetadataItemName = String
|
||||
typealias LocalContents = [LocalMetadataItem]
|
||||
typealias CloudContents = [CloudMetadataItem]
|
||||
|
||||
protocol SynchronizationStateManager {
|
||||
var currentLocalContents: LocalContents { get }
|
||||
var currentCloudContents: CloudContents { get }
|
||||
var localContentsGatheringIsFinished: Bool { get }
|
||||
var cloudContentGatheringIsFinished: Bool { get }
|
||||
|
||||
@discardableResult
|
||||
func resolveEvent(_ event: IncomingEvent) -> [OutgoingEvent]
|
||||
func resetState()
|
||||
}
|
||||
|
||||
enum IncomingEvent {
|
||||
case didFinishGatheringLocalContents(LocalContents)
|
||||
case didFinishGatheringCloudContents(CloudContents)
|
||||
case didUpdateLocalContents(LocalContents)
|
||||
case didUpdateCloudContents(CloudContents)
|
||||
}
|
||||
|
||||
enum OutgoingEvent {
|
||||
case createLocalItem(CloudMetadataItem)
|
||||
case updateLocalItem(CloudMetadataItem)
|
||||
case removeLocalItem(CloudMetadataItem)
|
||||
case startDownloading(CloudMetadataItem)
|
||||
case createCloudItem(LocalMetadataItem)
|
||||
case updateCloudItem(LocalMetadataItem)
|
||||
case removeCloudItem(LocalMetadataItem)
|
||||
case didReceiveError(SynchronizationError)
|
||||
case resolveVersionsConflict(CloudMetadataItem)
|
||||
case resolveInitialSynchronizationConflict(LocalMetadataItem)
|
||||
case didFinishInitialSynchronization
|
||||
}
|
||||
|
||||
final class DefaultSynchronizationStateManager: SynchronizationStateManager {
|
||||
|
||||
// MARK: - Public properties
|
||||
private(set) var localContentsGatheringIsFinished = false
|
||||
private(set) var cloudContentGatheringIsFinished = false
|
||||
|
||||
private(set) var currentLocalContents: LocalContents = []
|
||||
private(set) var currentCloudContents: CloudContents = [] {
|
||||
didSet {
|
||||
updateFilteredCloudContents()
|
||||
}
|
||||
}
|
||||
|
||||
// Cached derived arrays
|
||||
private var trashedCloudContents: [CloudMetadataItem] = []
|
||||
private var notTrashedCloudContents: [CloudMetadataItem] = []
|
||||
private var downloadedCloudContents: [CloudMetadataItem] = []
|
||||
private var notDownloadedCloudContents: [CloudMetadataItem] = []
|
||||
|
||||
private var isInitialSynchronization: Bool
|
||||
|
||||
init(isInitialSynchronization: Bool) {
|
||||
self.isInitialSynchronization = isInitialSynchronization
|
||||
}
|
||||
|
||||
// MARK: - Public methods
|
||||
@discardableResult
|
||||
func resolveEvent(_ event: IncomingEvent) -> [OutgoingEvent] {
|
||||
let outgoingEvents: [OutgoingEvent]
|
||||
switch event {
|
||||
case .didFinishGatheringLocalContents(let contents):
|
||||
localContentsGatheringIsFinished = true
|
||||
outgoingEvents = resolveDidFinishGathering(localContents: contents, cloudContents: currentCloudContents)
|
||||
case .didFinishGatheringCloudContents(let contents):
|
||||
cloudContentGatheringIsFinished = true
|
||||
outgoingEvents = resolveDidFinishGathering(localContents: currentLocalContents, cloudContents: contents)
|
||||
case .didUpdateLocalContents(let contents):
|
||||
outgoingEvents = resolveDidUpdateLocalContents(contents)
|
||||
case .didUpdateCloudContents(let contents):
|
||||
outgoingEvents = resolveDidUpdateCloudContents(contents)
|
||||
}
|
||||
return outgoingEvents
|
||||
}
|
||||
|
||||
func resetState() {
|
||||
currentLocalContents.removeAll()
|
||||
currentCloudContents.removeAll()
|
||||
localContentsGatheringIsFinished = false
|
||||
cloudContentGatheringIsFinished = false
|
||||
}
|
||||
|
||||
// MARK: - Private methods
|
||||
private func updateFilteredCloudContents() {
|
||||
trashedCloudContents = currentCloudContents.filter { $0.isRemoved }
|
||||
notTrashedCloudContents = currentCloudContents.filter { !$0.isRemoved }
|
||||
}
|
||||
|
||||
private func resolveDidFinishGathering(localContents: LocalContents, cloudContents: CloudContents) -> [OutgoingEvent] {
|
||||
currentLocalContents = localContents
|
||||
currentCloudContents = cloudContents
|
||||
guard localContentsGatheringIsFinished, cloudContentGatheringIsFinished else { return [] }
|
||||
|
||||
var outgoingEvents: [OutgoingEvent]
|
||||
switch (localContents.isEmpty, cloudContents.isEmpty) {
|
||||
case (true, true):
|
||||
outgoingEvents = []
|
||||
case (true, false):
|
||||
outgoingEvents = notTrashedCloudContents.map { .createLocalItem($0) }
|
||||
case (false, true):
|
||||
outgoingEvents = localContents.map { .createCloudItem($0) }
|
||||
case (false, false):
|
||||
var events = [OutgoingEvent]()
|
||||
if isInitialSynchronization {
|
||||
events.append(contentsOf: resolveInitialSynchronizationConflicts(localContents: localContents, cloudContents: cloudContents))
|
||||
}
|
||||
events.append(contentsOf: resolveDidUpdateCloudContents(cloudContents))
|
||||
events.append(contentsOf: resolveDidUpdateLocalContents(localContents))
|
||||
outgoingEvents = events
|
||||
}
|
||||
if isInitialSynchronization {
|
||||
outgoingEvents.append(.didFinishInitialSynchronization)
|
||||
isInitialSynchronization = false
|
||||
}
|
||||
return outgoingEvents
|
||||
}
|
||||
|
||||
private func resolveDidUpdateLocalContents(_ localContents: LocalContents) -> [OutgoingEvent] {
|
||||
let itemsToRemoveFromCloudContainer = Self.getItemsToRemoveFromCloudContainer(currentLocalContents: currentLocalContents,
|
||||
newLocalContents: localContents)
|
||||
let itemsToCreateInCloudContainer = Self.getItemsToCreateInCloudContainer(notTrashedCloudContents: notTrashedCloudContents,
|
||||
trashedCloudContents: trashedCloudContents,
|
||||
localContents: localContents)
|
||||
let itemsToUpdateInCloudContainer = Self.getItemsToUpdateInCloudContainer(notTrashedCloudContents: notTrashedCloudContents,
|
||||
localContents: localContents,
|
||||
isInitialSynchronization: isInitialSynchronization)
|
||||
|
||||
var outgoingEvents = [OutgoingEvent]()
|
||||
itemsToRemoveFromCloudContainer.forEach { outgoingEvents.append(.removeCloudItem($0)) }
|
||||
itemsToCreateInCloudContainer.forEach { outgoingEvents.append(.createCloudItem($0)) }
|
||||
itemsToUpdateInCloudContainer.forEach { outgoingEvents.append(.updateCloudItem($0)) }
|
||||
|
||||
currentLocalContents = localContents
|
||||
return outgoingEvents
|
||||
}
|
||||
|
||||
private func resolveDidUpdateCloudContents(_ cloudContents: CloudContents) -> [OutgoingEvent] {
|
||||
var outgoingEvents = [OutgoingEvent]()
|
||||
currentCloudContents = cloudContents
|
||||
|
||||
// 1. Handle errors
|
||||
let errors = Self.getItemsWithErrors(cloudContents)
|
||||
errors.forEach { outgoingEvents.append(.didReceiveError($0)) }
|
||||
|
||||
// 2. Handle merge conflicts
|
||||
let itemsWithUnresolvedConflicts = Self.getItemsToResolveConflicts(notTrashedCloudContents: notTrashedCloudContents)
|
||||
itemsWithUnresolvedConflicts.forEach { outgoingEvents.append(.resolveVersionsConflict($0)) }
|
||||
|
||||
// Merge conflicts should be resolved at first.
|
||||
guard itemsWithUnresolvedConflicts.isEmpty else {
|
||||
return outgoingEvents
|
||||
}
|
||||
|
||||
let itemsToRemoveFromLocalContainer = Self.getItemsToRemoveFromLocalContainer(notTrashedCloudContents: notTrashedCloudContents,
|
||||
trashedCloudContents: trashedCloudContents,
|
||||
localContents: currentLocalContents)
|
||||
let itemsToCreateInLocalContainer = Self.getItemsToCreateInLocalContainer(notTrashedCloudContents: notTrashedCloudContents,
|
||||
localContents: currentLocalContents)
|
||||
let itemsToUpdateInLocalContainer = Self.getItemsToUpdateInLocalContainer(notTrashedCloudContents: notTrashedCloudContents,
|
||||
localContents: currentLocalContents,
|
||||
isInitialSynchronization: isInitialSynchronization)
|
||||
|
||||
// 3. Handle not downloaded items
|
||||
itemsToCreateInLocalContainer.notDownloaded.forEach { outgoingEvents.append(.startDownloading($0)) }
|
||||
itemsToUpdateInLocalContainer.notDownloaded.forEach { outgoingEvents.append(.startDownloading($0)) }
|
||||
|
||||
// 4. Handle downloaded items
|
||||
itemsToRemoveFromLocalContainer.forEach { outgoingEvents.append(.removeLocalItem($0)) }
|
||||
itemsToCreateInLocalContainer.downloaded.forEach { outgoingEvents.append(.createLocalItem($0)) }
|
||||
itemsToUpdateInLocalContainer.downloaded.forEach { outgoingEvents.append(.updateLocalItem($0)) }
|
||||
|
||||
return outgoingEvents
|
||||
}
|
||||
|
||||
private func resolveInitialSynchronizationConflicts(localContents: LocalContents, cloudContents: CloudContents) -> [OutgoingEvent] {
|
||||
let itemsInInitialConflict = localContents.filter { cloudContents.containsByName($0) }
|
||||
guard !itemsInInitialConflict.isEmpty else {
|
||||
return []
|
||||
}
|
||||
return itemsInInitialConflict.map { .resolveInitialSynchronizationConflict($0) }
|
||||
}
|
||||
|
||||
private static func getItemsToRemoveFromCloudContainer(currentLocalContents: LocalContents, newLocalContents: LocalContents) -> LocalContents {
|
||||
currentLocalContents.filter { !newLocalContents.containsByName($0) }
|
||||
}
|
||||
|
||||
private static func getItemsToCreateInCloudContainer(notTrashedCloudContents: CloudContents, trashedCloudContents: CloudContents, localContents: LocalContents) -> LocalContents {
|
||||
localContents.reduce(into: LocalContents()) { result, localItem in
|
||||
if !notTrashedCloudContents.containsByName(localItem) && !trashedCloudContents.containsByName(localItem) {
|
||||
result.append(localItem)
|
||||
} else if !notTrashedCloudContents.containsByName(localItem),
|
||||
let trashedCloudItem = trashedCloudContents.firstByName(localItem),
|
||||
trashedCloudItem.lastModificationDate < localItem.lastModificationDate {
|
||||
// If Cloud .Trash contains item and it's last modification date is less than the local item's last modification date than file should be recreated.
|
||||
result.append(localItem)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static func getItemsToUpdateInCloudContainer(notTrashedCloudContents: CloudContents, localContents: LocalContents, isInitialSynchronization: Bool) -> LocalContents {
|
||||
guard !isInitialSynchronization else { return [] }
|
||||
// Due to the initial sync all conflicted local items will be duplicated with different name and replaced by the cloud items to avoid a data loss.
|
||||
return localContents.reduce(into: LocalContents()) { result, localItem in
|
||||
if let cloudItem = notTrashedCloudContents.firstByName(localItem),
|
||||
localItem.lastModificationDate > cloudItem.lastModificationDate {
|
||||
result.append(localItem)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static func getItemsWithErrors(_ cloudContents: CloudContents) -> [SynchronizationError] {
|
||||
cloudContents.reduce(into: [SynchronizationError](), { partialResult, cloudItem in
|
||||
if let downloadingError = cloudItem.downloadingError, let synchronizationError = SynchronizationError.fromError(downloadingError) {
|
||||
partialResult.append(synchronizationError)
|
||||
}
|
||||
if let uploadingError = cloudItem.uploadingError, let synchronizationError = SynchronizationError.fromError(uploadingError) {
|
||||
partialResult.append(synchronizationError)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
private static func getItemsToRemoveFromLocalContainer(notTrashedCloudContents: CloudContents, trashedCloudContents: CloudContents, localContents: LocalContents) -> CloudContents {
|
||||
trashedCloudContents.reduce(into: CloudContents()) { result, cloudItem in
|
||||
// Items shouldn't be removed if newer version of the item isn't in the trash.
|
||||
if let notTrashedCloudItem = notTrashedCloudContents.firstByName(cloudItem), notTrashedCloudItem.lastModificationDate > cloudItem.lastModificationDate {
|
||||
return
|
||||
}
|
||||
if let localItemValue = localContents.firstByName(cloudItem),
|
||||
cloudItem.lastModificationDate >= localItemValue.lastModificationDate {
|
||||
result.append(cloudItem)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static func getItemsToCreateInLocalContainer(notTrashedCloudContents: CloudContents, localContents: LocalContents) -> CloudContents {
|
||||
notTrashedCloudContents.withUnresolvedConflicts(false).filter { !localContents.containsByName($0) }
|
||||
}
|
||||
|
||||
private static func getItemsToUpdateInLocalContainer(notTrashedCloudContents: CloudContents, localContents: LocalContents, isInitialSynchronization: Bool) -> CloudContents {
|
||||
notTrashedCloudContents.withUnresolvedConflicts(false).reduce(into: CloudContents()) { result, cloudItem in
|
||||
if let localItemValue = localContents.firstByName(cloudItem) {
|
||||
// Due to the initial sync all conflicted local items will be duplicated with different name and replaced by the cloud items to avoid a data loss.
|
||||
if isInitialSynchronization {
|
||||
result.append(cloudItem)
|
||||
} else if cloudItem.lastModificationDate > localItemValue.lastModificationDate {
|
||||
result.append(cloudItem)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static func getItemsToResolveConflicts(notTrashedCloudContents: CloudContents) -> CloudContents {
|
||||
notTrashedCloudContents.withUnresolvedConflicts(true)
|
||||
}
|
||||
}
|
||||
269
iphone/Maps/Core/iCloud/iCloudDocumentsDirectoryMonitor.swift
Normal file
269
iphone/Maps/Core/iCloud/iCloudDocumentsDirectoryMonitor.swift
Normal file
|
|
@ -0,0 +1,269 @@
|
|||
protocol CloudDirectoryMonitor: DirectoryMonitor {
|
||||
var fileManager: FileManager { get }
|
||||
var ubiquitousDocumentsDirectory: URL? { get }
|
||||
var delegate: CloudDirectoryMonitorDelegate? { get set }
|
||||
|
||||
func fetchUbiquityDirectoryUrl(completion: ((Result<URL, Error>) -> Void)?)
|
||||
func isCloudAvailable() -> Bool
|
||||
}
|
||||
|
||||
protocol CloudDirectoryMonitorDelegate : AnyObject {
|
||||
func didFinishGathering(contents: CloudContents)
|
||||
func didUpdate(contents: CloudContents)
|
||||
func didReceiveCloudMonitorError(_ error: Error)
|
||||
}
|
||||
|
||||
private let kUDCloudIdentityKey = "com.apple.organicmaps.UbiquityIdentityToken"
|
||||
private let kDocumentsDirectoryName = "Documents"
|
||||
|
||||
class iCloudDocumentsDirectoryMonitor: NSObject, CloudDirectoryMonitor {
|
||||
|
||||
static let sharedContainerIdentifier: String = {
|
||||
var identifier = "iCloud.app.organicmaps"
|
||||
#if DEBUG
|
||||
identifier.append(".debug")
|
||||
#endif
|
||||
return identifier
|
||||
}()
|
||||
|
||||
let containerIdentifier: String
|
||||
let fileManager: FileManager
|
||||
private let fileType: FileType // TODO: Should be removed when the nested directory support will be implemented
|
||||
private(set) var metadataQuery: NSMetadataQuery?
|
||||
private(set) var ubiquitousDocumentsDirectory: URL?
|
||||
|
||||
// MARK: - Public properties
|
||||
private(set) var state: DirectoryMonitorState = .stopped
|
||||
weak var delegate: CloudDirectoryMonitorDelegate?
|
||||
|
||||
init(fileManager: FileManager = .default, cloudContainerIdentifier: String = iCloudDocumentsDirectoryMonitor.sharedContainerIdentifier, fileType: FileType) {
|
||||
self.fileManager = fileManager
|
||||
self.containerIdentifier = cloudContainerIdentifier
|
||||
self.fileType = fileType
|
||||
super.init()
|
||||
|
||||
fetchUbiquityDirectoryUrl()
|
||||
subscribeOnMetadataQueryNotifications()
|
||||
subscribeOnCloudAvailabilityNotifications()
|
||||
}
|
||||
|
||||
// MARK: - Public methods
|
||||
func start(completion: ((Result<URL, Error>) -> Void)? = nil) {
|
||||
guard isCloudAvailable() else {
|
||||
completion?(.failure(SynchronizationError.iCloudIsNotAvailable))
|
||||
return
|
||||
}
|
||||
fetchUbiquityDirectoryUrl { [weak self] result in
|
||||
guard let self else { return }
|
||||
switch result {
|
||||
case .failure(let error):
|
||||
completion?(.failure(error))
|
||||
case .success(let url):
|
||||
LOG(.debug, "iCloudMonitor: Start")
|
||||
self.startQuery()
|
||||
self.state = .started
|
||||
completion?(.success(url))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func stop() {
|
||||
guard state != .stopped else { return }
|
||||
LOG(.debug, "iCloudMonitor: Stop")
|
||||
stopQuery()
|
||||
state = .stopped
|
||||
}
|
||||
|
||||
func resume() {
|
||||
guard state != .started else { return }
|
||||
LOG(.debug, "iCloudMonitor: Resume")
|
||||
metadataQuery?.enableUpdates()
|
||||
state = .started
|
||||
}
|
||||
|
||||
func pause() {
|
||||
guard state != .paused else { return }
|
||||
LOG(.debug, "iCloudMonitor: Pause")
|
||||
metadataQuery?.disableUpdates()
|
||||
state = .paused
|
||||
}
|
||||
|
||||
func fetchUbiquityDirectoryUrl(completion: ((Result<URL, Error>) -> Void)? = nil) {
|
||||
if let ubiquitousDocumentsDirectory {
|
||||
completion?(.success(ubiquitousDocumentsDirectory))
|
||||
return
|
||||
}
|
||||
DispatchQueue.global().async {
|
||||
guard let containerUrl = self.fileManager.url(forUbiquityContainerIdentifier: self.containerIdentifier) else {
|
||||
LOG(.debug, "iCloudMonitor: Failed to retrieve container's URL for:\(self.containerIdentifier)")
|
||||
completion?(.failure(SynchronizationError.containerNotFound))
|
||||
return
|
||||
}
|
||||
let documentsContainerUrl = containerUrl.appendingPathComponent(kDocumentsDirectoryName)
|
||||
if !self.fileManager.fileExists(atPath: documentsContainerUrl.path) {
|
||||
LOG(.debug, "iCloudMonitor: Creating directory at path: \(documentsContainerUrl.path)")
|
||||
do {
|
||||
try self.fileManager.createDirectory(at: documentsContainerUrl, withIntermediateDirectories: true)
|
||||
} catch {
|
||||
completion?(.failure(SynchronizationError.containerNotFound))
|
||||
}
|
||||
}
|
||||
LOG(.debug, "iCloudMonitor: Ubiquity directory URL: \(documentsContainerUrl)")
|
||||
self.ubiquitousDocumentsDirectory = documentsContainerUrl
|
||||
completion?(.success(documentsContainerUrl))
|
||||
}
|
||||
}
|
||||
|
||||
func isCloudAvailable() -> Bool {
|
||||
let cloudToken = fileManager.ubiquityIdentityToken
|
||||
guard let cloudToken else {
|
||||
UserDefaults.standard.removeObject(forKey: kUDCloudIdentityKey)
|
||||
LOG(.debug, "iCloudMonitor: Cloud is not available. Cloud token is nil.")
|
||||
return false
|
||||
}
|
||||
do {
|
||||
let data = try NSKeyedArchiver.archivedData(withRootObject: cloudToken, requiringSecureCoding: true)
|
||||
UserDefaults.standard.set(data, forKey: kUDCloudIdentityKey)
|
||||
return true
|
||||
} catch {
|
||||
UserDefaults.standard.removeObject(forKey: kUDCloudIdentityKey)
|
||||
LOG(.debug, "iCloudMonitor: Failed to archive cloud token: \(error)")
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
class func buildMetadataQuery(for fileType: FileType) -> NSMetadataQuery {
|
||||
let metadataQuery = NSMetadataQuery()
|
||||
metadataQuery.notificationBatchingInterval = 1
|
||||
metadataQuery.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
|
||||
metadataQuery.predicate = NSPredicate(format: "%K LIKE %@", NSMetadataItemFSNameKey, "*.\(fileType.fileExtension)")
|
||||
metadataQuery.sortDescriptors = [NSSortDescriptor(key: NSMetadataItemFSNameKey, ascending: true)]
|
||||
return metadataQuery
|
||||
}
|
||||
|
||||
class func getContentsFromNotification(_ notification: Notification, _ onError: (Error) -> Void) -> CloudContents {
|
||||
guard let metadataQuery = notification.object as? NSMetadataQuery,
|
||||
let metadataItems = metadataQuery.results as? [NSMetadataItem] else {
|
||||
return []
|
||||
}
|
||||
|
||||
let cloudMetadataItems = CloudContents(metadataItems.compactMap { item in
|
||||
do {
|
||||
return try CloudMetadataItem(metadataItem: item)
|
||||
} catch {
|
||||
onError(error)
|
||||
return nil
|
||||
}
|
||||
})
|
||||
return cloudMetadataItems
|
||||
}
|
||||
|
||||
// There are no ways to retrieve the content of iCloud's .Trash directory on the macOS because it uses different file system and place trashed content in the /Users/<user_name>/.Trash which cannot be observed without access.
|
||||
// When we get a new notification and retrieve the metadata from the object the actual list of items in iOS contains both current and deleted files (which is in .Trash/ directory now) but on macOS we only have absence of the file. So there are no way to get list of deleted items on macOS on didFinishGathering state.
|
||||
// Due to didUpdate state we can get the list of deleted items on macOS from the userInfo property but cannot get their new url.
|
||||
class func getTrashContentsFromNotification(_ notification: Notification, _ onError: (Error) -> Void) -> CloudContents {
|
||||
guard let removedItems = notification.userInfo?[NSMetadataQueryUpdateRemovedItemsKey] as? [NSMetadataItem] else { return [] }
|
||||
return CloudContents(removedItems.compactMap { metadataItem in
|
||||
do {
|
||||
var item = try CloudMetadataItem(metadataItem: metadataItem)
|
||||
// on macOS deleted file will not be in the ./Trash directory, but it doesn't mean that it is not removed because it is placed in the NSMetadataQueryUpdateRemovedItems array.
|
||||
item.isRemoved = true
|
||||
return item
|
||||
} catch {
|
||||
onError(error)
|
||||
return nil
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
class func getTrashedContentsFromTrashDirectory(fileManager: FileManager, ubiquitousDocumentsDirectory: URL?, onError: (Error) -> Void) -> CloudContents {
|
||||
// There are no ways to retrieve the content of iCloud's .Trash directory on macOS.
|
||||
if #available(iOS 14.0, *), ProcessInfo.processInfo.isiOSAppOnMac {
|
||||
return []
|
||||
}
|
||||
// On iOS we can get the list of deleted items from the .Trash directory but only when iCloud is enabled.
|
||||
guard let ubiquitousDocumentsDirectory,
|
||||
let trashDirectoryUrl = try? fileManager.trashDirectoryUrl(for: ubiquitousDocumentsDirectory),
|
||||
let removedItems = try? fileManager.contentsOfDirectory(at: trashDirectoryUrl,
|
||||
includingPropertiesForKeys: [.isDirectoryKey],
|
||||
options: [.skipsPackageDescendants, .skipsSubdirectoryDescendants]) else {
|
||||
return []
|
||||
}
|
||||
let removedCloudMetadataItems = CloudContents(removedItems.compactMap { url in
|
||||
do {
|
||||
var item = try CloudMetadataItem(fileUrl: url)
|
||||
item.isRemoved = true
|
||||
return item
|
||||
} catch {
|
||||
onError(error)
|
||||
return nil
|
||||
}
|
||||
})
|
||||
return removedCloudMetadataItems
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Private
|
||||
private extension iCloudDocumentsDirectoryMonitor {
|
||||
|
||||
func subscribeOnCloudAvailabilityNotifications() {
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(cloudAvailabilityChanged(_:)), name: .NSUbiquityIdentityDidChange, object: nil)
|
||||
}
|
||||
|
||||
// TODO: - Actually this notification was never called. If user disable the iCloud for the current app during the active state the app will be relaunched. Needs to investigate additional cases when this notification can be sent.
|
||||
@objc func cloudAvailabilityChanged(_ notification: Notification) {
|
||||
LOG(.debug, "iCloudMonitor: Cloud availability changed to : \(isCloudAvailable())")
|
||||
isCloudAvailable() ? startQuery() : stopQuery()
|
||||
}
|
||||
|
||||
// MARK: - MetadataQuery
|
||||
func subscribeOnMetadataQueryNotifications() {
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(queryDidFinishGathering(_:)), name: NSNotification.Name.NSMetadataQueryDidFinishGathering, object: nil)
|
||||
NotificationCenter.default.addObserver(self, selector: #selector(queryDidUpdate(_:)), name: NSNotification.Name.NSMetadataQueryDidUpdate, object: nil)
|
||||
}
|
||||
|
||||
func startQuery() {
|
||||
metadataQuery = Self.buildMetadataQuery(for: fileType)
|
||||
guard let metadataQuery, !metadataQuery.isStarted else { return }
|
||||
LOG(.debug, "iCloudMonitor: Start metadata query")
|
||||
metadataQuery.start()
|
||||
}
|
||||
|
||||
func stopQuery() {
|
||||
LOG(.debug, "iCloudMonitor: Stop metadata query")
|
||||
metadataQuery?.stop()
|
||||
metadataQuery = nil
|
||||
}
|
||||
|
||||
@objc func queryDidFinishGathering(_ notification: Notification) {
|
||||
guard isCloudAvailable() else { return }
|
||||
metadataQuery?.disableUpdates()
|
||||
LOG(.debug, "iCloudMonitor: Query did finish gathering")
|
||||
let contents = Self.getContentsFromNotification(notification, metadataQueryErrorHandler)
|
||||
let trashedContents = Self.getTrashedContentsFromTrashDirectory(fileManager: fileManager,
|
||||
ubiquitousDocumentsDirectory: ubiquitousDocumentsDirectory,
|
||||
onError: metadataQueryErrorHandler)
|
||||
LOG(.debug, "iCloudMonitor: Cloud contents count: \(contents.count)")
|
||||
LOG(.debug, "iCloudMonitor: Trashed contents count: \(trashedContents.count)")
|
||||
delegate?.didFinishGathering(contents: contents + trashedContents)
|
||||
metadataQuery?.enableUpdates()
|
||||
}
|
||||
|
||||
@objc func queryDidUpdate(_ notification: Notification) {
|
||||
guard isCloudAvailable() else { return }
|
||||
metadataQuery?.disableUpdates()
|
||||
LOG(.debug, "iCloudMonitor: Query did update")
|
||||
let contents = Self.getContentsFromNotification(notification, metadataQueryErrorHandler)
|
||||
let trashedContents = Self.getTrashContentsFromNotification(notification, metadataQueryErrorHandler)
|
||||
LOG(.debug, "iCloudMonitor: Cloud contents count: \(contents.count)")
|
||||
LOG(.debug, "iCloudMonitor: Trashed contents count: \(trashedContents.count)")
|
||||
delegate?.didUpdate(contents: contents + trashedContents)
|
||||
metadataQuery?.enableUpdates()
|
||||
}
|
||||
|
||||
private var metadataQueryErrorHandler: (Error) -> Void {
|
||||
{ [weak self] error in
|
||||
self?.delegate?.didReceiveCloudMonitorError(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -471,8 +471,15 @@
|
|||
ED1263AB2B6F99F900AD99F3 /* UIView+AddSeparator.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED1263AA2B6F99F900AD99F3 /* UIView+AddSeparator.swift */; };
|
||||
ED1ADA332BC6B1B40029209F /* CarPlayServiceTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED1ADA322BC6B1B40029209F /* CarPlayServiceTests.swift */; };
|
||||
ED3EAC202B03C88100220A4A /* BottomTabBarButton.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED3EAC1F2B03C88100220A4A /* BottomTabBarButton.swift */; };
|
||||
ED63CEB92BDF8F9D006155C4 /* SettingsTableViewiCloudSwitchCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED63CEB62BDF8F9C006155C4 /* SettingsTableViewiCloudSwitchCell.swift */; };
|
||||
ED79A5AB2BD7AA9C00952D1F /* LoadingOverlayViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5AA2BD7AA9C00952D1F /* LoadingOverlayViewController.swift */; };
|
||||
ED79A5AD2BD7BA0F00952D1F /* UIApplication+LoadingOverlay.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5AC2BD7BA0F00952D1F /* UIApplication+LoadingOverlay.swift */; };
|
||||
ED79A5D32BDF8D6100952D1F /* CloudStorageManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5CB2BDF8D6100952D1F /* CloudStorageManager.swift */; };
|
||||
ED79A5D42BDF8D6100952D1F /* MetadataItem.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5CC2BDF8D6100952D1F /* MetadataItem.swift */; };
|
||||
ED79A5D52BDF8D6100952D1F /* SynchronizationError.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5CD2BDF8D6100952D1F /* SynchronizationError.swift */; };
|
||||
ED79A5D62BDF8D6100952D1F /* iCloudDocumentsDirectoryMonitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5CE2BDF8D6100952D1F /* iCloudDocumentsDirectoryMonitor.swift */; };
|
||||
ED79A5D72BDF8D6100952D1F /* SynchronizationStateManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5CF2BDF8D6100952D1F /* SynchronizationStateManager.swift */; };
|
||||
ED79A5D82BDF8D6100952D1F /* DefaultLocalDirectoryMonitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED79A5D02BDF8D6100952D1F /* DefaultLocalDirectoryMonitor.swift */; };
|
||||
ED9966802B94FBC20083CE55 /* ColorPicker.swift in Sources */ = {isa = PBXBuildFile; fileRef = ED99667D2B94FBC20083CE55 /* ColorPicker.swift */; };
|
||||
EDBD68072B625724005DD151 /* LocationServicesDisabledAlert.xib in Resources */ = {isa = PBXBuildFile; fileRef = EDBD68062B625724005DD151 /* LocationServicesDisabledAlert.xib */; };
|
||||
EDBD680B2B62572E005DD151 /* LocationServicesDisabledAlert.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDBD680A2B62572E005DD151 /* LocationServicesDisabledAlert.swift */; };
|
||||
|
|
@ -480,6 +487,14 @@
|
|||
EDE243DD2B6D2E640057369B /* AboutController.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDE243D52B6CF3980057369B /* AboutController.swift */; };
|
||||
EDE243E52B6D3F400057369B /* OSMView.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDE243E42B6D3F400057369B /* OSMView.swift */; };
|
||||
EDE243E72B6D55610057369B /* InfoView.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDE243E02B6D3EA00057369B /* InfoView.swift */; };
|
||||
EDF8386F2C00AE31007E4E67 /* LocalDirectoryMonitorDelegateMock.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF838372C009A0A007E4E67 /* LocalDirectoryMonitorDelegateMock.swift */; };
|
||||
EDF838702C00AE31007E4E67 /* DefaultLocalDirectoryMonitorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF838382C009A0A007E4E67 /* DefaultLocalDirectoryMonitorTests.swift */; };
|
||||
EDF838712C00AE31007E4E67 /* SynchronizationStateManagerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF838392C009A0A007E4E67 /* SynchronizationStateManagerTests.swift */; };
|
||||
EDF838722C00AE37007E4E67 /* MetadataItemStubs.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF8383E2C009A0A007E4E67 /* MetadataItemStubs.swift */; };
|
||||
EDF838772C00B217007E4E67 /* UbiquitousDirectoryMonitorDelegateMock.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF8383B2C009A0A007E4E67 /* UbiquitousDirectoryMonitorDelegateMock.swift */; };
|
||||
EDF838782C00B217007E4E67 /* iCloudDirectoryMonitorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF8383C2C009A0A007E4E67 /* iCloudDirectoryMonitorTests.swift */; };
|
||||
EDF838792C00B217007E4E67 /* FileManagerMock.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF8383D2C009A0A007E4E67 /* FileManagerMock.swift */; };
|
||||
EDF838842C00B640007E4E67 /* SynchronizationFileWriter.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDF838812C00B640007E4E67 /* SynchronizationFileWriter.swift */; };
|
||||
EDFDFB462B7139490013A44C /* AboutInfo.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDFDFB452B7139490013A44C /* AboutInfo.swift */; };
|
||||
EDFDFB482B7139670013A44C /* SocialMedia.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDFDFB472B7139670013A44C /* SocialMedia.swift */; };
|
||||
EDFDFB4A2B722A310013A44C /* SocialMediaCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = EDFDFB492B722A310013A44C /* SocialMediaCollectionViewCell.swift */; };
|
||||
|
|
@ -1364,8 +1379,15 @@
|
|||
ED3EAC1F2B03C88100220A4A /* BottomTabBarButton.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BottomTabBarButton.swift; sourceTree = "<group>"; };
|
||||
ED48BBB817C2B1E2003E7E92 /* CircleView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CircleView.h; sourceTree = "<group>"; };
|
||||
ED48BBB917C2B1E2003E7E92 /* CircleView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CircleView.m; sourceTree = "<group>"; };
|
||||
ED63CEB62BDF8F9C006155C4 /* SettingsTableViewiCloudSwitchCell.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SettingsTableViewiCloudSwitchCell.swift; sourceTree = "<group>"; };
|
||||
ED79A5AA2BD7AA9C00952D1F /* LoadingOverlayViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LoadingOverlayViewController.swift; sourceTree = "<group>"; };
|
||||
ED79A5AC2BD7BA0F00952D1F /* UIApplication+LoadingOverlay.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "UIApplication+LoadingOverlay.swift"; sourceTree = "<group>"; };
|
||||
ED79A5CB2BDF8D6100952D1F /* CloudStorageManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CloudStorageManager.swift; sourceTree = "<group>"; };
|
||||
ED79A5CC2BDF8D6100952D1F /* MetadataItem.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MetadataItem.swift; sourceTree = "<group>"; };
|
||||
ED79A5CD2BDF8D6100952D1F /* SynchronizationError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizationError.swift; sourceTree = "<group>"; };
|
||||
ED79A5CE2BDF8D6100952D1F /* iCloudDocumentsDirectoryMonitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = iCloudDocumentsDirectoryMonitor.swift; sourceTree = "<group>"; };
|
||||
ED79A5CF2BDF8D6100952D1F /* SynchronizationStateManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizationStateManager.swift; sourceTree = "<group>"; };
|
||||
ED79A5D02BDF8D6100952D1F /* DefaultLocalDirectoryMonitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DefaultLocalDirectoryMonitor.swift; sourceTree = "<group>"; };
|
||||
ED99667D2B94FBC20083CE55 /* ColorPicker.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ColorPicker.swift; sourceTree = "<group>"; };
|
||||
EDBD68062B625724005DD151 /* LocationServicesDisabledAlert.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = LocationServicesDisabledAlert.xib; sourceTree = "<group>"; };
|
||||
EDBD680A2B62572E005DD151 /* LocationServicesDisabledAlert.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationServicesDisabledAlert.swift; sourceTree = "<group>"; };
|
||||
|
|
@ -1373,6 +1395,14 @@
|
|||
EDE243D52B6CF3980057369B /* AboutController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AboutController.swift; sourceTree = "<group>"; };
|
||||
EDE243E02B6D3EA00057369B /* InfoView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InfoView.swift; sourceTree = "<group>"; };
|
||||
EDE243E42B6D3F400057369B /* OSMView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OSMView.swift; sourceTree = "<group>"; };
|
||||
EDF838372C009A0A007E4E67 /* LocalDirectoryMonitorDelegateMock.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LocalDirectoryMonitorDelegateMock.swift; sourceTree = "<group>"; };
|
||||
EDF838382C009A0A007E4E67 /* DefaultLocalDirectoryMonitorTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DefaultLocalDirectoryMonitorTests.swift; sourceTree = "<group>"; };
|
||||
EDF838392C009A0A007E4E67 /* SynchronizationStateManagerTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizationStateManagerTests.swift; sourceTree = "<group>"; };
|
||||
EDF8383B2C009A0A007E4E67 /* UbiquitousDirectoryMonitorDelegateMock.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = UbiquitousDirectoryMonitorDelegateMock.swift; sourceTree = "<group>"; };
|
||||
EDF8383C2C009A0A007E4E67 /* iCloudDirectoryMonitorTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = iCloudDirectoryMonitorTests.swift; sourceTree = "<group>"; };
|
||||
EDF8383D2C009A0A007E4E67 /* FileManagerMock.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FileManagerMock.swift; sourceTree = "<group>"; };
|
||||
EDF8383E2C009A0A007E4E67 /* MetadataItemStubs.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MetadataItemStubs.swift; sourceTree = "<group>"; };
|
||||
EDF838812C00B640007E4E67 /* SynchronizationFileWriter.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizationFileWriter.swift; sourceTree = "<group>"; };
|
||||
EDFDFB452B7139490013A44C /* AboutInfo.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AboutInfo.swift; sourceTree = "<group>"; };
|
||||
EDFDFB472B7139670013A44C /* SocialMedia.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SocialMedia.swift; sourceTree = "<group>"; };
|
||||
EDFDFB492B722A310013A44C /* SocialMediaCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SocialMediaCollectionViewCell.swift; sourceTree = "<group>"; };
|
||||
|
|
@ -1912,6 +1942,7 @@
|
|||
340475281E081A4600C92850 /* Core */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
ED79A5CA2BDF8D6100952D1F /* iCloud */,
|
||||
994AEBE323AB763C0079B81F /* Theme */,
|
||||
993F54F6237C622700545511 /* DeepLink */,
|
||||
CDCA27822245090900167D87 /* EventListening */,
|
||||
|
|
@ -3025,6 +3056,20 @@
|
|||
path = LoadingOverlay;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
ED79A5CA2BDF8D6100952D1F /* iCloud */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
ED79A5CB2BDF8D6100952D1F /* CloudStorageManager.swift */,
|
||||
EDF838812C00B640007E4E67 /* SynchronizationFileWriter.swift */,
|
||||
ED79A5CF2BDF8D6100952D1F /* SynchronizationStateManager.swift */,
|
||||
ED79A5CE2BDF8D6100952D1F /* iCloudDocumentsDirectoryMonitor.swift */,
|
||||
ED79A5D02BDF8D6100952D1F /* DefaultLocalDirectoryMonitor.swift */,
|
||||
ED79A5CC2BDF8D6100952D1F /* MetadataItem.swift */,
|
||||
ED79A5CD2BDF8D6100952D1F /* SynchronizationError.swift */,
|
||||
);
|
||||
path = iCloud;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
ED99667C2B94FBC20083CE55 /* ColorPicker */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
|
|
@ -3628,6 +3673,7 @@
|
|||
F6E2FD371E097BA00083EBEC /* Cells */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
ED63CEB62BDF8F9C006155C4 /* SettingsTableViewiCloudSwitchCell.swift */,
|
||||
F6E2FD381E097BA00083EBEC /* SettingsTableViewLinkCell.swift */,
|
||||
F6E2FD391E097BA00083EBEC /* SettingsTableViewSelectableCell.swift */,
|
||||
F6E2FD3A1E097BA00083EBEC /* SettingsTableViewSwitchCell.swift */,
|
||||
|
|
@ -4037,7 +4083,7 @@
|
|||
6741A9981BF340DE002C974C /* resources-xhdpi_light in Resources */,
|
||||
6741A9611BF340DE002C974C /* resources-xhdpi_dark in Resources */,
|
||||
6741A94D1BF340DE002C974C /* resources-xxhdpi_light in Resources */,
|
||||
3404F49E2028A2430090E401 /* BMCActionsCreateCell.xib in Resources */,
|
||||
3404F49E2028A2430090E401 /* BMCActionsCell.xib in Resources */,
|
||||
6741A9551BF340DE002C974C /* resources-xxhdpi_dark in Resources */,
|
||||
340E1EF51E2F614400CE49BF /* SearchFilters.storyboard in Resources */,
|
||||
340E1EF81E2F614400CE49BF /* Settings.storyboard in Resources */,
|
||||
|
|
@ -4174,6 +4220,7 @@
|
|||
F6E2FF631E097BA00083EBEC /* MWMTTSLanguageViewController.mm in Sources */,
|
||||
4715273524907F8200E91BBA /* BookmarkColorViewController.swift in Sources */,
|
||||
47E3C7292111E614008B3B27 /* FadeInAnimatedTransitioning.swift in Sources */,
|
||||
ED79A5D42BDF8D6100952D1F /* MetadataItem.swift in Sources */,
|
||||
34AB667D1FC5AA330078E451 /* MWMRoutePreview.mm in Sources */,
|
||||
993DF11B23F6BDB100AC231A /* UIViewRenderer.swift in Sources */,
|
||||
99C964302428C27A00E41723 /* PlacePageHeaderView.swift in Sources */,
|
||||
|
|
@ -4199,9 +4246,11 @@
|
|||
3454D7D41E07F045004AF2AD /* UIImageView+Coloring.m in Sources */,
|
||||
993DF11D23F6BDB100AC231A /* UIToolbarRenderer.swift in Sources */,
|
||||
99A906E923F6F7030005872B /* WikiDescriptionViewController.swift in Sources */,
|
||||
ED79A5D62BDF8D6100952D1F /* iCloudDocumentsDirectoryMonitor.swift in Sources */,
|
||||
EDFDFB522B726F1A0013A44C /* ButtonsStackView.swift in Sources */,
|
||||
993DF11023F6BDB100AC231A /* MWMButtonRenderer.swift in Sources */,
|
||||
3463BA671DE81DB90082417F /* MWMTrafficButtonViewController.mm in Sources */,
|
||||
ED79A5D52BDF8D6100952D1F /* SynchronizationError.swift in Sources */,
|
||||
993DF10323F6BDB100AC231A /* MainTheme.swift in Sources */,
|
||||
34AB66051FC5AA320078E451 /* MWMNavigationDashboardManager+Entity.mm in Sources */,
|
||||
993DF12A23F6BDB100AC231A /* Style.swift in Sources */,
|
||||
|
|
@ -4231,6 +4280,7 @@
|
|||
99A906E523F6F7030005872B /* ActionBarViewController.swift in Sources */,
|
||||
47B9065421C7FA400079C85E /* UIImageView+WebImage.m in Sources */,
|
||||
F6E2FF481E097BA00083EBEC /* SettingsTableViewSelectableCell.swift in Sources */,
|
||||
ED63CEB92BDF8F9D006155C4 /* SettingsTableViewiCloudSwitchCell.swift in Sources */,
|
||||
47CA68D4250043C000671019 /* BookmarksListPresenter.swift in Sources */,
|
||||
F6E2FF451E097BA00083EBEC /* SettingsTableViewLinkCell.swift in Sources */,
|
||||
34C9BD0A1C6DBCDA000DC38D /* MWMNavigationController.m in Sources */,
|
||||
|
|
@ -4340,6 +4390,7 @@
|
|||
F6E2FF661E097BA00083EBEC /* MWMTTSSettingsViewController.mm in Sources */,
|
||||
3454D7C21E07F045004AF2AD /* NSString+Categories.m in Sources */,
|
||||
34E7761F1F14DB48003040B3 /* PlacePageArea.swift in Sources */,
|
||||
ED79A5D82BDF8D6100952D1F /* DefaultLocalDirectoryMonitor.swift in Sources */,
|
||||
4728F69322CF89A400E00028 /* GradientView.swift in Sources */,
|
||||
F6381BF61CD12045004CA943 /* LocaleTranslator.mm in Sources */,
|
||||
9917D17F2397B1D600A7E06E /* IPadModalPresentationController.swift in Sources */,
|
||||
|
|
@ -4411,6 +4462,7 @@
|
|||
998927402449ECC200260CE2 /* BottomMenuItemCell.swift in Sources */,
|
||||
F6E2FEE21E097BA00083EBEC /* MWMSearchManager.mm in Sources */,
|
||||
F6E2FE221E097BA00083EBEC /* MWMOpeningHoursEditorViewController.mm in Sources */,
|
||||
ED79A5D72BDF8D6100952D1F /* SynchronizationStateManager.swift in Sources */,
|
||||
999FC12B23ABB4B800B0E6F9 /* FontStyleSheet.swift in Sources */,
|
||||
47CA68DA2500469400671019 /* BookmarksListBuilder.swift in Sources */,
|
||||
34D3AFE21E376F7E004100F9 /* UITableView+Updates.swift in Sources */,
|
||||
|
|
@ -4440,6 +4492,7 @@
|
|||
340475711E081A4600C92850 /* MWMSettings.mm in Sources */,
|
||||
33046832219C57180041F3A8 /* CategorySettingsViewController.swift in Sources */,
|
||||
3404756E1E081A4600C92850 /* MWMSearch.mm in Sources */,
|
||||
EDF838842C00B640007E4E67 /* SynchronizationFileWriter.swift in Sources */,
|
||||
6741AA191BF340DE002C974C /* MWMDownloaderDialogCell.m in Sources */,
|
||||
993DF10823F6BDB100AC231A /* IColors.swift in Sources */,
|
||||
4707E4B12372FE860017DF6E /* PlacePageViewController.swift in Sources */,
|
||||
|
|
@ -4451,6 +4504,7 @@
|
|||
6741AA1C1BF340DE002C974C /* MWMRoutingDisclaimerAlert.m in Sources */,
|
||||
34D3B0481E389D05004100F9 /* MWMNoteCell.m in Sources */,
|
||||
CD9AD967228067F500EC174A /* MapInfo.swift in Sources */,
|
||||
ED79A5D32BDF8D6100952D1F /* CloudStorageManager.swift in Sources */,
|
||||
6741AA1D1BF340DE002C974C /* MWMDownloadTransitMapAlert.mm in Sources */,
|
||||
471A7BBE2481A3D000A0D4C1 /* EditBookmarkViewController.swift in Sources */,
|
||||
993DF0C923F6BD0600AC231A /* ElevationDetailsBuilder.swift in Sources */,
|
||||
|
|
|
|||
|
|
@ -4,9 +4,9 @@ protocol SettingsTableViewSwitchCellDelegate {
|
|||
}
|
||||
|
||||
@objc
|
||||
final class SettingsTableViewSwitchCell: MWMTableViewCell {
|
||||
class SettingsTableViewSwitchCell: MWMTableViewCell {
|
||||
|
||||
private let switchButton = UISwitch()
|
||||
let switchButton = UISwitch()
|
||||
|
||||
@IBOutlet weak var delegate: SettingsTableViewSwitchCellDelegate?
|
||||
|
||||
|
|
@ -24,6 +24,11 @@ final class SettingsTableViewSwitchCell: MWMTableViewCell {
|
|||
set { switchButton.isOn = newValue }
|
||||
}
|
||||
|
||||
@objc
|
||||
func setOn(_ isOn: Bool, animated: Bool) {
|
||||
switchButton.setOn(isOn, animated: animated)
|
||||
}
|
||||
|
||||
override func awakeFromNib() {
|
||||
super.awakeFromNib()
|
||||
setupCell()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,34 @@
|
|||
final class SettingsTableViewiCloudSwitchCell: SettingsTableViewSwitchCell {
|
||||
|
||||
override func awakeFromNib() {
|
||||
super.awakeFromNib()
|
||||
styleDetail()
|
||||
}
|
||||
|
||||
@objc
|
||||
func updateWithError(_ error: NSError?) {
|
||||
if let error = error as? SynchronizationError {
|
||||
switch error {
|
||||
case .fileUnavailable, .fileNotUploadedDueToQuota, .ubiquityServerNotAvailable:
|
||||
accessoryView = switchButton
|
||||
case .iCloudIsNotAvailable, .containerNotFound:
|
||||
accessoryView = nil
|
||||
accessoryType = .detailButton
|
||||
default:
|
||||
break
|
||||
}
|
||||
detailTextLabel?.text = error.localizedDescription
|
||||
} else {
|
||||
accessoryView = switchButton
|
||||
detailTextLabel?.text?.removeAll()
|
||||
}
|
||||
setNeedsLayout()
|
||||
}
|
||||
|
||||
private func styleDetail() {
|
||||
let detailTextLabelStyle = "regular12:blackSecondaryText"
|
||||
detailTextLabel?.setStyleAndApply(detailTextLabelStyle)
|
||||
detailTextLabel?.numberOfLines = 0
|
||||
detailTextLabel?.lineBreakMode = .byWordWrapping
|
||||
}
|
||||
}
|
||||
|
|
@ -2,6 +2,7 @@
|
|||
#import "MWMAuthorizationCommon.h"
|
||||
#import "MWMTextToSpeech+CPP.h"
|
||||
#import "SwiftBridge.h"
|
||||
#import "MWMActivityViewController.h"
|
||||
|
||||
#import <CoreApi/CoreApi.h>
|
||||
|
||||
|
|
@ -9,6 +10,8 @@
|
|||
|
||||
using namespace power_management;
|
||||
|
||||
static NSString * const kUDDidShowICloudSynchronizationEnablingAlert = @"kUDDidShowICloudSynchronizationEnablingAlert";
|
||||
|
||||
@interface MWMSettingsViewController ()<SettingsTableViewSwitchCellDelegate>
|
||||
|
||||
@property(weak, nonatomic) IBOutlet SettingsTableViewLinkCell *profileCell;
|
||||
|
|
@ -29,6 +32,7 @@ using namespace power_management;
|
|||
@property(weak, nonatomic) IBOutlet SettingsTableViewSwitchCell *autoZoomCell;
|
||||
@property(weak, nonatomic) IBOutlet SettingsTableViewLinkCell *voiceInstructionsCell;
|
||||
@property(weak, nonatomic) IBOutlet SettingsTableViewLinkCell *drivingOptionsCell;
|
||||
@property(weak, nonatomic) IBOutlet SettingsTableViewiCloudSwitchCell *iCloudSynchronizationCell;
|
||||
|
||||
|
||||
@end
|
||||
|
|
@ -180,6 +184,14 @@ using namespace power_management;
|
|||
break;
|
||||
}
|
||||
[self.nightModeCell configWithTitle:L(@"pref_appearance_title") info:nightMode];
|
||||
|
||||
BOOL isICLoudSynchronizationEnabled = [MWMSettings iCLoudSynchronizationEnabled];
|
||||
[self.iCloudSynchronizationCell configWithDelegate:self
|
||||
title:@"iCloud Synchronization (Beta)"
|
||||
isOn:isICLoudSynchronizationEnabled];
|
||||
[CloudStorageManager.shared addObserver:self onErrorCompletionHandler:^(NSError * _Nullable error) {
|
||||
[self.iCloudSynchronizationCell updateWithError:error];
|
||||
}];
|
||||
}
|
||||
|
||||
- (void)show3dBuildingsAlert:(UITapGestureRecognizer *)recognizer {
|
||||
|
|
@ -209,6 +221,68 @@ using namespace power_management;
|
|||
[self.drivingOptionsCell configWithTitle:L(@"driving_options_title") info:@""];
|
||||
}
|
||||
|
||||
- (void)showICloudSynchronizationEnablingAlert:(void (^)(BOOL))isEnabled {
|
||||
UIAlertController * alertController = [UIAlertController alertControllerWithTitle:L(@"enable_icloud_synchronization_title")
|
||||
message:L(@"enable_icloud_synchronization_message")
|
||||
preferredStyle:UIAlertControllerStyleAlert];
|
||||
UIAlertAction * enableButton = [UIAlertAction actionWithTitle:L(@"enable")
|
||||
style:UIAlertActionStyleDefault
|
||||
handler:^(UIAlertAction * action) {
|
||||
[self setICloudSynchronizationEnablingAlertIsShown];
|
||||
isEnabled(YES);
|
||||
}];
|
||||
UIAlertAction * backupButton = [UIAlertAction actionWithTitle:L(@"backup")
|
||||
style:UIAlertActionStyleDefault
|
||||
handler:^(UIAlertAction * action) {
|
||||
[MWMBookmarksManager.sharedManager shareAllCategoriesWithCompletion:^(MWMBookmarksShareStatus status, NSURL * _Nonnull url) {
|
||||
switch (status) {
|
||||
case MWMBookmarksShareStatusSuccess: {
|
||||
MWMActivityViewController * shareController = [MWMActivityViewController shareControllerForURL:url message:L(@"share_bookmarks_email_body") completionHandler:^(UIActivityType _Nullable activityType, BOOL completed, NSArray * _Nullable returnedItems, NSError * _Nullable activityError) {
|
||||
[self setICloudSynchronizationEnablingAlertIsShown];
|
||||
isEnabled(completed);
|
||||
}];
|
||||
[shareController presentInParentViewController:self anchorView:self.iCloudSynchronizationCell];
|
||||
break;
|
||||
}
|
||||
case MWMBookmarksShareStatusEmptyCategory:
|
||||
[[MWMToast toastWithText:L(@"bookmarks_error_title_share_empty")] show];
|
||||
isEnabled(NO);
|
||||
break;
|
||||
case MWMBookmarksShareStatusArchiveError:
|
||||
case MWMBookmarksShareStatusFileError:
|
||||
[[MWMToast toastWithText:L(@"dialog_routing_system_error")] show];
|
||||
isEnabled(NO);
|
||||
break;
|
||||
}
|
||||
}];
|
||||
}];
|
||||
UIAlertAction * cancelButton = [UIAlertAction actionWithTitle:L(@"cancel")
|
||||
style:UIAlertActionStyleCancel
|
||||
handler:^(UIAlertAction * action) {
|
||||
isEnabled(NO);
|
||||
}];
|
||||
|
||||
[alertController addAction:cancelButton];
|
||||
if (![MWMBookmarksManager.sharedManager areAllCategoriesEmpty])
|
||||
[alertController addAction:backupButton];
|
||||
[alertController addAction:enableButton];
|
||||
[self presentViewController:alertController animated:YES completion:nil];
|
||||
}
|
||||
|
||||
- (void)setICloudSynchronizationEnablingAlertIsShown {
|
||||
[NSUserDefaults.standardUserDefaults setBool:YES forKey:kUDDidShowICloudSynchronizationEnablingAlert];
|
||||
}
|
||||
|
||||
- (void)showICloudIsDisabledAlert {
|
||||
UIAlertController * alertController = [UIAlertController alertControllerWithTitle:L(@"icloud_disabled_title")
|
||||
message:L(@"icloud_disabled_message")
|
||||
preferredStyle:UIAlertControllerStyleAlert];
|
||||
UIAlertAction * okButton = [UIAlertAction actionWithTitle:L(@"ok")
|
||||
style:UIAlertActionStyleCancel
|
||||
handler:nil];
|
||||
[alertController addAction:okButton];
|
||||
[self presentViewController:alertController animated:YES completion:nil];
|
||||
}
|
||||
|
||||
#pragma mark - SettingsTableViewSwitchCellDelegate
|
||||
|
||||
|
|
@ -241,12 +315,22 @@ using namespace power_management;
|
|||
auto &f = GetFramework();
|
||||
f.AllowAutoZoom(value);
|
||||
f.SaveAutoZoom(value);
|
||||
} else if (cell == self.iCloudSynchronizationCell) {
|
||||
if (![NSUserDefaults.standardUserDefaults boolForKey:kUDDidShowICloudSynchronizationEnablingAlert]) {
|
||||
[self showICloudSynchronizationEnablingAlert:^(BOOL isEnabled) {
|
||||
[self.iCloudSynchronizationCell setOn:isEnabled animated:YES];
|
||||
[MWMSettings setICLoudSynchronizationEnabled:isEnabled];
|
||||
}];
|
||||
} else {
|
||||
[MWMSettings setICLoudSynchronizationEnabled:value];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#pragma mark - UITableViewDelegate
|
||||
|
||||
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
|
||||
[tableView deselectRowAtIndexPath:indexPath animated:true];
|
||||
auto cell = [tableView cellForRowAtIndexPath:indexPath];
|
||||
if (cell == self.profileCell) {
|
||||
[self performSegueWithIdentifier:@"SettingsToProfileSegue" sender:nil];
|
||||
|
|
@ -267,6 +351,13 @@ using namespace power_management;
|
|||
}
|
||||
}
|
||||
|
||||
- (void)tableView:(UITableView *)tableView accessoryButtonTappedForRowWithIndexPath:(NSIndexPath *)indexPath {
|
||||
auto cell = [tableView cellForRowAtIndexPath:indexPath];
|
||||
if (cell == self.iCloudSynchronizationCell) {
|
||||
[self showICloudIsDisabledAlert];
|
||||
}
|
||||
}
|
||||
|
||||
#pragma mark - UITableViewDataSource
|
||||
|
||||
- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
|
||||
|
|
|
|||
|
|
@ -284,6 +284,31 @@
|
|||
</subviews>
|
||||
</tableViewCellContentView>
|
||||
</tableViewCell>
|
||||
<tableViewCell contentMode="scaleToFill" selectionStyle="default" hidesAccessoryWhenEditing="NO" indentationLevel="1" indentationWidth="0.0" reuseIdentifier="SettingsTableViewSwitchCell" textLabel="QEX-D4-ejR" detailTextLabel="Iy7-de-pvk" style="IBUITableViewCellStyleSubtitle" id="E6M-av-wQu" userLabel="iCloud synchronization" customClass="SettingsTableViewiCloudSwitchCell" customModule="Organic_Maps" customModuleProvider="target">
|
||||
<rect key="frame" x="0.0" y="586" width="414" height="44"/>
|
||||
<autoresizingMask key="autoresizingMask"/>
|
||||
<tableViewCellContentView key="contentView" opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="center" tableViewCell="E6M-av-wQu" id="PbS-4v-dzK">
|
||||
<rect key="frame" x="0.0" y="0.0" width="414" height="44"/>
|
||||
<autoresizingMask key="autoresizingMask"/>
|
||||
<subviews>
|
||||
<label opaque="NO" multipleTouchEnabled="YES" contentMode="left" insetsLayoutMarginsFromSafeArea="NO" text="iCloud Synchronization (Beta)" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" id="QEX-D4-ejR">
|
||||
<rect key="frame" x="20" y="0.0" width="374" height="44"/>
|
||||
<autoresizingMask key="autoresizingMask"/>
|
||||
<color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
|
||||
<fontDescription key="fontDescription" type="system" pointSize="0.0"/>
|
||||
<nil key="textColor"/>
|
||||
<nil key="highlightedColor"/>
|
||||
</label>
|
||||
<label opaque="NO" multipleTouchEnabled="YES" contentMode="left" insetsLayoutMarginsFromSafeArea="NO" text="Error" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" id="Iy7-de-pvk">
|
||||
<rect key="frame" x="20" y="22.5" width="28" height="14.5"/>
|
||||
<autoresizingMask key="autoresizingMask"/>
|
||||
<fontDescription key="fontDescription" type="system" pointSize="0.0"/>
|
||||
<nil key="textColor"/>
|
||||
<nil key="highlightedColor"/>
|
||||
</label>
|
||||
</subviews>
|
||||
</tableViewCellContentView>
|
||||
</tableViewCell>
|
||||
</cells>
|
||||
</tableViewSection>
|
||||
<tableViewSection headerTitle="НАВИГАЦИЯ" id="E4E-hs-9xW">
|
||||
|
|
@ -392,6 +417,7 @@
|
|||
<outlet property="compassCalibrationCell" destination="P5e-67-f4k" id="KcB-EC-S2y"/>
|
||||
<outlet property="drivingOptionsCell" destination="KrE-Sc-fI1" id="XOl-eI-xJX"/>
|
||||
<outlet property="fontScaleCell" destination="pri-6G-9Zb" id="rHJ-ZT-lwM"/>
|
||||
<outlet property="iCloudSynchronizationCell" destination="E6M-av-wQu" id="05q-Wq-SQa"/>
|
||||
<outlet property="is3dCell" destination="0Lf-xU-P2U" id="obI-bL-FLh"/>
|
||||
<outlet property="mobileInternetCell" destination="6NC-QX-WiF" id="L1V-gS-sTe"/>
|
||||
<outlet property="nightModeCell" destination="QNt-XC-xma" id="nSn-Jr-KuZ"/>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue