584 lines
24 KiB
Swift
584 lines
24 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 materialId: Int?
|
|
var autoRetouchState: TravelAlbumAutoRetouchState
|
|
var autoRetouchTemplateId: String?
|
|
var retouchedPath: 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 = "",
|
|
materialId: Int? = nil,
|
|
autoRetouchState: TravelAlbumAutoRetouchState = .none,
|
|
autoRetouchTemplateId: String? = nil,
|
|
retouchedPath: 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.materialId = materialId
|
|
self.autoRetouchState = autoRetouchState
|
|
self.autoRetouchTemplateId = autoRetouchTemplateId
|
|
self.retouchedPath = retouchedPath
|
|
self.updatedAt = updatedAt
|
|
}
|
|
|
|
private enum CodingKeys: String, CodingKey {
|
|
case id, sourceId, clientPhotoId, fileName, localPath, thumbnailPath, capturedAt
|
|
case fileSizeBytes, status, progress, errorMessage, albumId, userId, remoteUrl, materialId
|
|
case autoRetouchState, autoRetouchTemplateId, retouchedPath, 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) ?? ""
|
|
materialId = try container.decodeIfPresent(Int.self, forKey: .materialId)
|
|
autoRetouchState = try container.decodeIfPresent(
|
|
TravelAlbumAutoRetouchState.self,
|
|
forKey: .autoRetouchState
|
|
) ?? .none
|
|
autoRetouchTemplateId = try container.decodeIfPresent(String.self, forKey: .autoRetouchTemplateId)
|
|
retouchedPath = try container.decodeIfPresent(String.self, forKey: .retouchedPath) ?? ""
|
|
updatedAt = try container.decodeIfPresent(Int64.self, forKey: .updatedAt) ?? 0
|
|
}
|
|
|
|
/// 把中断中的传输恢复为待上传，避免重进页面卡在上传中。
|
|
func normalizedAfterInterruptedTransfer() -> TravelAlbumOTGPhotoRecord {
|
|
let interruptedUpload = status == .transferring || status == .uploading
|
|
let interruptedRetouch = autoRetouchState == .processing
|
|
guard interruptedUpload || interruptedRetouch else { return self }
|
|
var copy = self
|
|
if interruptedUpload {
|
|
copy.status = copy.materialId == nil ? .pending : .uploaded
|
|
copy.progress = copy.materialId == nil ? 0 : 100
|
|
copy.errorMessage = nil
|
|
}
|
|
if interruptedRetouch {
|
|
copy.autoRetouchState = copy.materialId == nil ? .none : .failed
|
|
}
|
|
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 != scoped {
|
|
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
|
|
}
|
|
|
|
/// 写入自动 AI 修图结果，返回当前相册预览目录中的文件 URL。
|
|
func writeRetouchedImage(_ data: Data, filename: String, albumId: Int) throws -> URL {
|
|
let directory = try previewsDirectory(albumId: albumId)
|
|
let sanitized = PTPHelper.sanitizeFilename(filename)
|
|
let stem = (sanitized as NSString).deletingPathExtension
|
|
let preferredName = "\(stem)_retouched.jpg"
|
|
var candidate = directory.appendingPathComponent(preferredName)
|
|
var counter = 1
|
|
while fileManager.fileExists(atPath: candidate.path), counter < 10_000 {
|
|
candidate = directory.appendingPathComponent("\(stem)_retouched_\(counter).jpg")
|
|
counter += 1
|
|
}
|
|
try data.write(to: candidate, options: .atomic)
|
|
return candidate
|
|
}
|
|
|
|
/// 返回写入索引用的相对路径。
|
|
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
|
|
}
|
|
if let retouchedURL = absoluteURL(for: record.retouchedPath, albumId: albumId) {
|
|
resolved.retouchedPath = retouchedURL.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, record.retouchedPath].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
|
|
}
|
|
if !record.retouchedPath.isEmpty {
|
|
normalized.retouchedPath = record.retouchedPath.hasPrefix("/")
|
|
? relativePath(for: URL(fileURLWithPath: record.retouchedPath), albumId: albumId)
|
|
: record.retouchedPath
|
|
}
|
|
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)
|
|
}
|
|
}
|