533 lines
22 KiB
Swift
533 lines
22 KiB
Swift
//
|
||
// TravelAlbumOTGPhotoStore.swift
|
||
// suixinkan
|
||
//
|
||
|
||
import Foundation
|
||
|
||
/// 生成并规范化旅拍照片的客户端唯一标识。
|
||
enum TravelAlbumClientPhotoID {
|
||
/// 生成小写、带连字符的 UUID v4 字符串。
|
||
static func make() -> String {
|
||
UUID().uuidString.lowercased()
|
||
}
|
||
|
||
/// 规范化服务端或本地保存的客户端照片 ID。
|
||
static func normalize(_ value: String?) -> String? {
|
||
guard let normalized = value?
|
||
.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
.lowercased(),
|
||
!normalized.isEmpty else {
|
||
return nil
|
||
}
|
||
return normalized
|
||
}
|
||
}
|
||
|
||
/// OTG 传输照片上传状态，对齐 Android `WiredTransferUploadStatus`。
|
||
enum TravelAlbumOTGUploadStatus: String, Codable, Equatable, Sendable {
|
||
case pending = "PENDING"
|
||
case transferring = "TRANSFERRING"
|
||
case uploading = "UPLOADING"
|
||
case uploaded = "UPLOADED"
|
||
case failed = "FAILED"
|
||
}
|
||
|
||
/// OTG 照片格式上传偏好。
|
||
enum TravelAlbumOTGPhotoFormatOption: String, CaseIterable, Equatable, Sendable {
|
||
case jpg = "JPG"
|
||
case raw = "RAW"
|
||
case jpegRaw = "JPEG+RAW"
|
||
}
|
||
|
||
/// OTG 本地照片记录，按账号、景区、门店与服务端相册 ID 隔离保存。
|
||
struct TravelAlbumOTGPhotoRecord: Codable, Hashable, Sendable {
|
||
let id: String
|
||
let sourceId: String
|
||
var clientPhotoId: String
|
||
let fileName: String
|
||
var localPath: String
|
||
var thumbnailPath: String
|
||
let capturedAt: String
|
||
let fileSizeBytes: Int64
|
||
var status: TravelAlbumOTGUploadStatus
|
||
var progress: Int
|
||
var errorMessage: String?
|
||
let albumId: Int
|
||
let userId: String
|
||
var remoteUrl: String
|
||
var updatedAt: Int64
|
||
|
||
/// 创建 OTG 本地照片记录。
|
||
init(
|
||
id: String,
|
||
sourceId: String? = nil,
|
||
clientPhotoId: String = TravelAlbumClientPhotoID.make(),
|
||
fileName: String,
|
||
localPath: String,
|
||
thumbnailPath: String = "",
|
||
capturedAt: String,
|
||
fileSizeBytes: Int64,
|
||
status: TravelAlbumOTGUploadStatus,
|
||
progress: Int = 0,
|
||
errorMessage: String? = nil,
|
||
albumId: Int,
|
||
userId: String,
|
||
remoteUrl: String = "",
|
||
updatedAt: Int64 = Int64(Date().timeIntervalSince1970 * 1000)
|
||
) {
|
||
self.id = id
|
||
self.sourceId = sourceId ?? id
|
||
self.clientPhotoId = TravelAlbumClientPhotoID.normalize(clientPhotoId) ?? TravelAlbumClientPhotoID.make()
|
||
self.fileName = fileName
|
||
self.localPath = localPath
|
||
self.thumbnailPath = thumbnailPath
|
||
self.capturedAt = capturedAt
|
||
self.fileSizeBytes = fileSizeBytes
|
||
self.status = status
|
||
self.progress = progress
|
||
self.errorMessage = errorMessage
|
||
self.albumId = albumId
|
||
self.userId = userId
|
||
self.remoteUrl = remoteUrl
|
||
self.updatedAt = updatedAt
|
||
}
|
||
|
||
private enum CodingKeys: String, CodingKey {
|
||
case id, sourceId, clientPhotoId, fileName, localPath, thumbnailPath, capturedAt
|
||
case fileSizeBytes, status, progress, errorMessage, albumId, userId, remoteUrl, updatedAt
|
||
}
|
||
|
||
/// 解码本地索引；旧版本缺少 `clientPhotoId` 时先保留为空，由 Store 一次性迁移并回写。
|
||
init(from decoder: Decoder) throws {
|
||
let container = try decoder.container(keyedBy: CodingKeys.self)
|
||
id = try container.decode(String.self, forKey: .id)
|
||
sourceId = try container.decodeIfPresent(String.self, forKey: .sourceId) ?? id
|
||
clientPhotoId = try container.decodeIfPresent(String.self, forKey: .clientPhotoId) ?? ""
|
||
fileName = try container.decode(String.self, forKey: .fileName)
|
||
localPath = try container.decode(String.self, forKey: .localPath)
|
||
thumbnailPath = try container.decodeIfPresent(String.self, forKey: .thumbnailPath) ?? ""
|
||
capturedAt = try container.decode(String.self, forKey: .capturedAt)
|
||
fileSizeBytes = try container.decodeIfPresent(Int64.self, forKey: .fileSizeBytes) ?? 0
|
||
status = try container.decode(TravelAlbumOTGUploadStatus.self, forKey: .status)
|
||
progress = try container.decodeIfPresent(Int.self, forKey: .progress) ?? 0
|
||
errorMessage = try container.decodeIfPresent(String.self, forKey: .errorMessage)
|
||
albumId = try container.decode(Int.self, forKey: .albumId)
|
||
userId = try container.decode(String.self, forKey: .userId)
|
||
remoteUrl = try container.decodeIfPresent(String.self, forKey: .remoteUrl) ?? ""
|
||
updatedAt = try container.decodeIfPresent(Int64.self, forKey: .updatedAt) ?? 0
|
||
}
|
||
|
||
/// 把中断中的传输恢复为待上传，避免重进页面卡在上传中。
|
||
func normalizedAfterInterruptedTransfer() -> TravelAlbumOTGPhotoRecord {
|
||
guard status == .transferring || status == .uploading else { return self }
|
||
var copy = self
|
||
copy.status = .pending
|
||
copy.progress = 0
|
||
copy.errorMessage = nil
|
||
copy.updatedAt = Int64(Date().timeIntervalSince1970 * 1000)
|
||
return copy
|
||
}
|
||
}
|
||
|
||
/// 相册内照片的持久化读写接口，供 OTG 边拍边传服务写入。
|
||
protocol PhotoRepositoryProtocol {
|
||
/// 读取指定服务端相册 ID 的本地照片记录。
|
||
func fetchPhotos(albumID: Int) throws -> [TravelAlbumOTGPhotoRecord]
|
||
|
||
/// 添加一张已下载到本地的照片。
|
||
@discardableResult
|
||
func addPhoto(albumID: Int, localPath: String, createdAt: Date) throws -> TravelAlbumOTGPhotoRecord
|
||
|
||
/// 删除指定照片及本地文件。
|
||
func deletePhoto(photoID: String, albumID: Int) throws
|
||
}
|
||
|
||
/// OTG 本地照片仓库，使用 JSON 索引和隔离目录保存照片。
|
||
final class TravelAlbumOTGPhotoRepository: PhotoRepositoryProtocol {
|
||
private let storage: TravelAlbumOTGPhotoStore
|
||
|
||
/// 初始化 OTG 本地照片仓库。
|
||
init(storage: TravelAlbumOTGPhotoStore = TravelAlbumOTGPhotoStore()) {
|
||
self.storage = storage
|
||
}
|
||
|
||
/// 读取指定服务端相册 ID 的本地照片记录。
|
||
func fetchPhotos(albumID: Int) throws -> [TravelAlbumOTGPhotoRecord] {
|
||
storage.load(albumId: albumID)
|
||
}
|
||
|
||
/// 添加一张已下载到本地的照片。
|
||
@discardableResult
|
||
func addPhoto(albumID: Int, localPath: String, createdAt: Date) throws -> TravelAlbumOTGPhotoRecord {
|
||
let fileURL = URL(fileURLWithPath: localPath)
|
||
let attributes = try? FileManager.default.attributesOfItem(atPath: localPath)
|
||
let size = (attributes?[.size] as? NSNumber)?.int64Value ?? 0
|
||
let userId = storage.context.userId
|
||
guard !userId.isEmpty else {
|
||
throw CameraError.connectionFailed("用户信息缺失，无法保存照片")
|
||
}
|
||
|
||
let record = TravelAlbumOTGPhotoRecord(
|
||
id: TravelAlbumOTGPhotoStore.photoId(for: fileURL.lastPathComponent, createdAt: createdAt),
|
||
fileName: fileURL.lastPathComponent,
|
||
localPath: storage.relativePath(for: fileURL, albumId: albumID),
|
||
capturedAt: TravelAlbumOTGPhotoStore.transferTimeText(createdAt),
|
||
fileSizeBytes: size,
|
||
status: .pending,
|
||
albumId: albumID,
|
||
userId: userId
|
||
)
|
||
storage.upsert(record, albumId: albumID)
|
||
return record
|
||
}
|
||
|
||
/// 删除指定照片及本地文件。
|
||
func deletePhoto(photoID: String, albumID: Int) throws {
|
||
storage.remove(albumId: albumID, photoId: photoID)
|
||
}
|
||
}
|
||
|
||
/// OTG 本地存储上下文，决定照片和索引的隔离目录。
|
||
struct TravelAlbumOTGStorageContext: Equatable, Sendable {
|
||
let accountCachePrefix: String
|
||
let userId: String
|
||
let scenicId: Int
|
||
let storeId: Int
|
||
|
||
/// 使用当前登录账号创建存储上下文。
|
||
static var current: TravelAlbumOTGStorageContext {
|
||
TravelAlbumOTGStorageContext(
|
||
accountCachePrefix: AppStore.shared.session.accountCachePrefix,
|
||
userId: AppStore.shared.session.userId,
|
||
scenicId: AppStore.shared.session.currentScenicId,
|
||
storeId: AppStore.shared.session.currentStoreId
|
||
)
|
||
}
|
||
}
|
||
|
||
/// 旅拍相册 OTG 本地照片存储，负责路径隔离、索引读写与文件清理。
|
||
final class TravelAlbumOTGPhotoStore {
|
||
let context: TravelAlbumOTGStorageContext
|
||
private let fileManager: FileManager
|
||
private let applicationSupportDirectory: URL
|
||
private let cachesDirectory: URL
|
||
|
||
/// 初始化旅拍相册 OTG 存储。
|
||
init(
|
||
context: TravelAlbumOTGStorageContext = .current,
|
||
fileManager: FileManager = .default,
|
||
applicationSupportDirectory: URL? = nil,
|
||
cachesDirectory: URL? = nil
|
||
) {
|
||
self.context = context
|
||
self.fileManager = fileManager
|
||
self.applicationSupportDirectory = applicationSupportDirectory
|
||
?? fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
|
||
self.cachesDirectory = cachesDirectory
|
||
?? fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
|
||
}
|
||
|
||
/// 读取相册照片记录。
|
||
func load(albumId: Int) -> [TravelAlbumOTGPhotoRecord] {
|
||
guard albumId > 0, !context.userId.isEmpty else { return [] }
|
||
guard let data = try? Data(contentsOf: indexURL(albumId: albumId)),
|
||
let decoded = try? JSONDecoder().decode([TravelAlbumOTGPhotoRecord].self, from: data) else {
|
||
return []
|
||
}
|
||
let scoped = decoded.filter { $0.albumId == albumId && $0.userId == context.userId }
|
||
let migrated = scoped.map { record -> TravelAlbumOTGPhotoRecord in
|
||
var copy = record
|
||
copy.clientPhotoId = TravelAlbumClientPhotoID.normalize(record.clientPhotoId)
|
||
?? TravelAlbumClientPhotoID.make()
|
||
return copy.normalizedAfterInterruptedTransfer()
|
||
}
|
||
if migrated.map(\.clientPhotoId) != scoped.map(\.clientPhotoId) {
|
||
save(migrated, albumId: albumId)
|
||
}
|
||
return migrated
|
||
.filter { isDisplayable($0, albumId: albumId) }
|
||
.sorted { $0.capturedAt > $1.capturedAt }
|
||
}
|
||
|
||
/// 保存相册照片记录。
|
||
func save(_ records: [TravelAlbumOTGPhotoRecord], albumId: Int) {
|
||
guard albumId > 0, !context.userId.isEmpty else { return }
|
||
let normalized = records
|
||
.filter { $0.albumId == albumId && $0.userId == context.userId }
|
||
.map { recordByPersistingRelativePaths($0, albumId: albumId) }
|
||
.sorted { $0.capturedAt > $1.capturedAt }
|
||
do {
|
||
try fileManager.createDirectory(at: albumRoot(albumId: albumId), withIntermediateDirectories: true)
|
||
let data = try JSONEncoder().encode(normalized)
|
||
try data.write(to: indexURL(albumId: albumId), options: .atomic)
|
||
} catch {
|
||
OTGLog.error(.connection, "save OTG photo records failed: \(error.localizedDescription)")
|
||
}
|
||
}
|
||
|
||
/// 插入或更新单条照片记录。
|
||
func upsert(_ record: TravelAlbumOTGPhotoRecord, albumId: Int) {
|
||
var records = load(albumId: albumId).filter { $0.id != record.id }
|
||
records.append(record)
|
||
save(records, albumId: albumId)
|
||
}
|
||
|
||
/// 删除单张照片记录并清理本地文件。
|
||
func remove(albumId: Int, photoId: String) {
|
||
guard albumId > 0, !photoId.isEmpty else { return }
|
||
let records = load(albumId: albumId)
|
||
records.filter { $0.id == photoId }.forEach(deleteFiles)
|
||
save(records.filter { $0.id != photoId }, albumId: albumId)
|
||
}
|
||
|
||
/// 清理整个相册的 OTG 本地缓存。
|
||
func clearAlbum(albumId: Int) {
|
||
guard albumId > 0 else { return }
|
||
try? fileManager.removeItem(at: albumRoot(albumId: albumId))
|
||
try? fileManager.removeItem(at: previewRoot(albumId: albumId))
|
||
}
|
||
|
||
/// 原片目录。
|
||
func originalsDirectory(albumId: Int) throws -> URL {
|
||
let url = albumRoot(albumId: albumId).appendingPathComponent("originals", isDirectory: true)
|
||
try fileManager.createDirectory(at: url, withIntermediateDirectories: true)
|
||
try excludeFromBackup(url)
|
||
return url
|
||
}
|
||
|
||
/// 预览目录。
|
||
func previewsDirectory(albumId: Int) throws -> URL {
|
||
let url = previewRoot(albumId: albumId)
|
||
try fileManager.createDirectory(at: url, withIntermediateDirectories: true)
|
||
return url
|
||
}
|
||
|
||
/// 在隔离原片目录下分配不冲突文件 URL。
|
||
func uniqueOriginalFileURL(filename: String, albumId: Int) throws -> URL {
|
||
let directory = try originalsDirectory(albumId: albumId)
|
||
let sanitized = PTPHelper.sanitizeFilename(filename)
|
||
let baseURL = directory.appendingPathComponent(sanitized)
|
||
if !fileManager.fileExists(atPath: baseURL.path) {
|
||
return baseURL
|
||
}
|
||
|
||
let stem = (sanitized as NSString).deletingPathExtension
|
||
let ext = (sanitized as NSString).pathExtension
|
||
var counter = 1
|
||
while counter < 10_000 {
|
||
let suffix = ext.isEmpty ? "\(stem)_\(counter)" : "\(stem)_\(counter).\(ext)"
|
||
let candidate = directory.appendingPathComponent(suffix)
|
||
if !fileManager.fileExists(atPath: candidate.path) {
|
||
return candidate
|
||
}
|
||
counter += 1
|
||
}
|
||
throw CameraError.connectionFailed("无法分配唯一文件名")
|
||
}
|
||
|
||
/// 写入原片数据，返回隔离目录中的文件 URL。
|
||
func writeImage(_ data: Data, filename: String, albumId: Int) throws -> URL {
|
||
let url = try uniqueOriginalFileURL(filename: filename, albumId: albumId)
|
||
try data.write(to: url, options: .atomic)
|
||
return url
|
||
}
|
||
|
||
/// 返回写入索引用的相对路径。
|
||
func relativePath(for url: URL, albumId: Int) -> String {
|
||
let path = url.standardizedFileURL.path
|
||
let originalRoot = albumRoot(albumId: albumId)
|
||
.appendingPathComponent("originals", isDirectory: true)
|
||
.standardizedFileURL
|
||
.path
|
||
if let relative = pathComponent(path, relativeTo: originalRoot) {
|
||
return "originals/\(relative)"
|
||
}
|
||
|
||
let previewPath = previewRoot(albumId: albumId).standardizedFileURL.path
|
||
if let relative = pathComponent(path, relativeTo: previewPath) {
|
||
return "previews/\(relative)"
|
||
}
|
||
|
||
return url.lastPathComponent
|
||
}
|
||
|
||
/// 把索引中的相对路径解析到当前沙盒绝对 URL。
|
||
func absoluteURL(for relativePath: String, albumId: Int) -> URL? {
|
||
let trimmed = relativePath.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !trimmed.isEmpty, !trimmed.hasPrefix("/") else { return nil }
|
||
if trimmed.hasPrefix("originals/") {
|
||
return albumRoot(albumId: albumId).appendingPathComponent(trimmed)
|
||
}
|
||
if trimmed.hasPrefix("previews/") {
|
||
return previewRoot(albumId: albumId)
|
||
.deletingLastPathComponent()
|
||
.appendingPathComponent(trimmed)
|
||
}
|
||
return albumRoot(albumId: albumId).appendingPathComponent(trimmed)
|
||
}
|
||
|
||
/// 判断索引相对路径对应的文件是否存在。
|
||
func fileExists(relativePath: String, albumId: Int) -> Bool {
|
||
guard let url = absoluteURL(for: relativePath, albumId: albumId) else { return false }
|
||
return fileManager.fileExists(atPath: url.path)
|
||
}
|
||
|
||
/// 返回可直接用于文件读取的记录副本。
|
||
func recordWithResolvedFilePaths(_ record: TravelAlbumOTGPhotoRecord, albumId: Int) -> TravelAlbumOTGPhotoRecord {
|
||
var resolved = record
|
||
if let localURL = absoluteURL(for: record.localPath, albumId: albumId) {
|
||
resolved.localPath = localURL.path
|
||
}
|
||
if let thumbnailURL = absoluteURL(for: record.thumbnailPath, albumId: albumId) {
|
||
resolved.thumbnailPath = thumbnailURL.path
|
||
}
|
||
return resolved
|
||
}
|
||
|
||
/// 生成稳定照片 ID。
|
||
static func photoId(for fileName: String, createdAt: Date) -> String {
|
||
let timestamp = Int64(createdAt.timeIntervalSince1970)
|
||
return "\(fileName.uppercased())_\(timestamp)"
|
||
}
|
||
|
||
/// Android 同款时间格式。
|
||
static func transferTimeText(_ date: Date) -> String {
|
||
let formatter = DateFormatter()
|
||
formatter.locale = Locale(identifier: "zh_CN")
|
||
formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
|
||
return formatter.string(from: date)
|
||
}
|
||
|
||
/// 格式化文件大小。
|
||
static func fileSizeText(_ bytes: Int64) -> String {
|
||
guard bytes > 0 else { return "--" }
|
||
let mb = Double(bytes) / 1024.0 / 1024.0
|
||
if mb >= 1024 {
|
||
return String(format: "%.2f GB", locale: Locale(identifier: "en_US_POSIX"), mb / 1024.0)
|
||
}
|
||
return String(format: "%.2f MB", locale: Locale(identifier: "en_US_POSIX"), mb)
|
||
}
|
||
|
||
private func albumRoot(albumId: Int) -> URL {
|
||
applicationSupportDirectory
|
||
.appendingPathComponent("TravelAlbumOTG", isDirectory: true)
|
||
.appendingPathComponent(safePathComponent(context.accountCachePrefix), isDirectory: true)
|
||
.appendingPathComponent("scenic_\(context.scenicId)", isDirectory: true)
|
||
.appendingPathComponent("store_\(context.storeId)", isDirectory: true)
|
||
.appendingPathComponent("album_\(albumId)", isDirectory: true)
|
||
}
|
||
|
||
private func previewRoot(albumId: Int) -> URL {
|
||
cachesDirectory
|
||
.appendingPathComponent("TravelAlbumOTG", isDirectory: true)
|
||
.appendingPathComponent(safePathComponent(context.accountCachePrefix), isDirectory: true)
|
||
.appendingPathComponent("scenic_\(context.scenicId)", isDirectory: true)
|
||
.appendingPathComponent("store_\(context.storeId)", isDirectory: true)
|
||
.appendingPathComponent("album_\(albumId)", isDirectory: true)
|
||
.appendingPathComponent("previews", isDirectory: true)
|
||
}
|
||
|
||
private func indexURL(albumId: Int) -> URL {
|
||
albumRoot(albumId: albumId).appendingPathComponent("records.json")
|
||
}
|
||
|
||
private func deleteFiles(_ record: TravelAlbumOTGPhotoRecord) {
|
||
[record.localPath, record.thumbnailPath].forEach { path in
|
||
guard !path.isEmpty else { return }
|
||
guard let url = absoluteURL(for: path, albumId: record.albumId) else { return }
|
||
try? fileManager.removeItem(at: url)
|
||
}
|
||
}
|
||
|
||
private func isDisplayable(_ record: TravelAlbumOTGPhotoRecord, albumId: Int) -> Bool {
|
||
if record.status == .uploaded { return true }
|
||
if !record.remoteUrl.isEmpty { return true }
|
||
if fileExists(relativePath: record.localPath, albumId: albumId) { return true }
|
||
if fileExists(relativePath: record.thumbnailPath, albumId: albumId) { return true }
|
||
return false
|
||
}
|
||
|
||
private func recordByPersistingRelativePaths(
|
||
_ record: TravelAlbumOTGPhotoRecord,
|
||
albumId: Int
|
||
) -> TravelAlbumOTGPhotoRecord {
|
||
var normalized = record
|
||
if !record.localPath.isEmpty {
|
||
normalized.localPath = record.localPath.hasPrefix("/")
|
||
? relativePath(for: URL(fileURLWithPath: record.localPath), albumId: albumId)
|
||
: record.localPath
|
||
}
|
||
if !record.thumbnailPath.isEmpty {
|
||
normalized.thumbnailPath = record.thumbnailPath.hasPrefix("/")
|
||
? relativePath(for: URL(fileURLWithPath: record.thumbnailPath), albumId: albumId)
|
||
: record.thumbnailPath
|
||
}
|
||
return normalized
|
||
}
|
||
|
||
private func pathComponent(_ path: String, relativeTo root: String) -> String? {
|
||
let prefix = root.hasSuffix("/") ? root : "\(root)/"
|
||
guard path.hasPrefix(prefix) else { return nil }
|
||
return String(path.dropFirst(prefix.count))
|
||
}
|
||
|
||
private func excludeFromBackup(_ url: URL) throws {
|
||
var resourceValues = URLResourceValues()
|
||
resourceValues.isExcludedFromBackup = true
|
||
var mutableURL = url
|
||
try mutableURL.setResourceValues(resourceValues)
|
||
}
|
||
|
||
private func safePathComponent(_ value: String) -> String {
|
||
let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !trimmed.isEmpty else { return "guest" }
|
||
let unsafe = CharacterSet(charactersIn: "/\\:?%*|\"<>")
|
||
return trimmed.unicodeScalars.reduce(into: "") { result, scalar in
|
||
result += unsafe.contains(scalar) ? "_" : String(scalar)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 按服务端客户端照片 ID 快照回写本地持久状态。
|
||
enum TravelAlbumOTGServerStatusPolicy {
|
||
/// 只处理请求发起时已存在且期间未变化的非活动记录。
|
||
static func reconcile(
|
||
records: [TravelAlbumOTGPhotoRecord],
|
||
baselineRecordsById: [String: TravelAlbumOTGPhotoRecord],
|
||
activePhotoIds: Set<String>,
|
||
serverClientPhotoIds: [String],
|
||
now: Int64
|
||
) -> [TravelAlbumOTGPhotoRecord] {
|
||
let serverIds = Set(serverClientPhotoIds.compactMap(TravelAlbumClientPhotoID.normalize))
|
||
return records.map { record in
|
||
guard baselineRecordsById[record.id] == record,
|
||
!activePhotoIds.contains(record.id) else {
|
||
return record
|
||
}
|
||
var copy = record
|
||
if let clientPhotoId = TravelAlbumClientPhotoID.normalize(record.clientPhotoId),
|
||
serverIds.contains(clientPhotoId) {
|
||
copy.status = .uploaded
|
||
copy.progress = 100
|
||
copy.errorMessage = nil
|
||
copy.updatedAt = now
|
||
} else if record.status == .uploaded {
|
||
copy.status = .pending
|
||
copy.progress = 0
|
||
copy.errorMessage = nil
|
||
copy.updatedAt = now
|
||
}
|
||
return copy
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 兼容从 `otg_swift` 同步来的边拍边传写入调用。
|
||
enum AlbumPhotoStorage {
|
||
/// 写入原片数据到当前账号与相册隔离目录。
|
||
static func writeImage(_ data: Data, filename: String, albumID: Int) throws -> URL {
|
||
try TravelAlbumOTGPhotoStore().writeImage(data, filename: filename, albumId: albumID)
|
||
}
|
||
}
|