Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import UIKit
import Models
import Shared
import Combine
import Defaults
import Foundation
import Integration
import BackupFeature
import DependencyInjection
import iCloudFeature
import DropboxFeature
import GoogleDriveFeature
enum RestorationStep {
case idle(CloudService, Backup?)
case downloading(Float, Float)
case failDownload(Error)
case parsingData
case done
}
extension RestorationStep: Equatable {
static func ==(lhs: RestorationStep, rhs: RestorationStep) -> Bool {
switch (lhs, rhs) {
case (.done, .done):
return true
case let (.failDownload(a), .failDownload(b)):
return a.localizedDescription == b.localizedDescription
case let (.downloading(a, b), .downloading(c, d)):
return a == c && b == d
case (.idle, _), (.downloading, _), (.parsingData, _),
(.done, _), (.failDownload, _):
return false
}
}
}
final class RestoreViewModel {
@Dependency private var iCloudService: iCloudInterface
@Dependency private var dropboxService: DropboxInterface
@Dependency private var googleService: GoogleDriveInterface
@KeyObject(.username, defaultValue: nil) var username: String?
var step: AnyPublisher<RestorationStep, Never> { stepRelay.eraseToAnyPublisher() }
private let ndf: String
private let settings: RestoreSettings
private let stepRelay: CurrentValueSubject<RestorationStep, Never>
init(ndf: String, settings: RestoreSettings) {
self.ndf = ndf
self.settings = settings
self.stepRelay = .init(.idle(settings.cloudService, settings.backup))
}
func didTapRestore() {
guard let backup = settings.backup else { fatalError() }
stepRelay.send(.downloading(0.0, backup.size))
switch settings.cloudService {
case .drive:
downloadBackupForDrive(backup)
case .dropbox:
downloadBackupForDropbox(backup)
case .icloud:
downloadBackupForiCloud(backup)
}
}
private func downloadBackupForDropbox(_ backup: Backup) {
dropboxService.downloadBackup(backup.id) { [weak self] in
guard let self = self else { return }
self.stepRelay.send(.downloading(backup.size, backup.size))
switch $0 {
case .success(let data):
self.continueRestoring(data: data)
case .failure(let error):
self.stepRelay.send(.failDownload(error))
}
}
}
private func downloadBackupForiCloud(_ backup: Backup) {
iCloudService.downloadBackup(backup.id) { [weak self] in
guard let self = self else { return }
self.stepRelay.send(.downloading(backup.size, backup.size))
switch $0 {
case .success(let data):
self.continueRestoring(data: data)
case .failure(let error):
self.stepRelay.send(.failDownload(error))
}
}
}
private func downloadBackupForDrive(_ backup: Backup) {
googleService.downloadBackup(backup.id) { [weak self] in
if let stepRelay = self?.stepRelay {
stepRelay.send(.downloading($0, backup.size))
}
} _: { [weak self] in
guard let self = self else { return }
switch $0 {
case .success(let data):
self.continueRestoring(data: data)
case .failure(let error):
self.stepRelay.send(.failDownload(error))
}
}
}
private func continueRestoring(data: Data) {
stepRelay.send(.parsingData)
DispatchQueue.global().async { [weak self] in
guard let self = self else { return }
let session = try! Session(backupFile: data, ndf: self.ndf)
DependencyInjection.Container.shared.register(session as SessionType)
self.stepRelay.send(.done)
}
}
}