557 lines
23 KiB
Swift
557 lines
23 KiB
Swift
import CoreLocation
|
|
import Foundation
|
|
import GRDB
|
|
import Photos
|
|
|
|
// MARK: - Models
|
|
|
|
/// Metadata for a single photo asset from the Photos library.
|
|
public struct PhotoAsset: Sendable {
|
|
public let localIdentifier: String
|
|
public let rawKind: Int // 0=image/photo, 1=video, 2=audio
|
|
public let rawSubtype: Int // bitmask: 4=screenshot, 8=live, 32=depth, 64k=slow-mo
|
|
public let width: Int
|
|
public let height: Int
|
|
public let fileSize: Int?
|
|
public let creationDate: Date?
|
|
public let modificationDate: Date?
|
|
public let latitude: Double?
|
|
public let longitude: Double?
|
|
public let isFavorite: Bool
|
|
public let isHidden: Bool
|
|
public let duration: TimeInterval
|
|
public let burstIdentifier: String?
|
|
public let originalFilename: String?
|
|
|
|
public var mediaTypeString: String {
|
|
switch rawKind {
|
|
case 1: return "video"
|
|
case 2: return "audio"
|
|
default: return rawSubtype & 8 != 0 ? "live_photo" : "image"
|
|
}
|
|
}
|
|
|
|
public var isScreenshot: Bool { rawSubtype & 4 != 0 }
|
|
public var isBurst: Bool { burstIdentifier != nil }
|
|
// Selfie detection deferred to server-side EXIF analysis.
|
|
public var isSelfie: Bool { false }
|
|
}
|
|
|
|
/// Metadata for a Photos library album/collection.
|
|
public struct PhotoAlbum: Sendable {
|
|
public let localIdentifier: String
|
|
public let title: String
|
|
public let albumTypeString: String
|
|
public let startDate: Date?
|
|
public let endDate: Date?
|
|
public let assetLocalIdentifiers: [String]
|
|
}
|
|
|
|
// MARK: - Reader
|
|
|
|
/// Reads metadata and binary data from the macOS Photos library.
|
|
///
|
|
/// ## Metadata reading strategy: direct SQLite via /bin/cp + GRDB
|
|
///
|
|
/// PHKit's `PHAsset.fetchAssets` requires a working XPC connection to `photolibraryd`.
|
|
/// Ad-hoc signed processes (no Apple Developer cert) cannot authenticate to the
|
|
/// `photolibraryd` XPC endpoint on macOS 14+, causing "Unable to send to server;
|
|
/// failed after 8 attempts" and an empty result from `fetchAssets`.
|
|
///
|
|
/// The workaround: copy `Photos.sqlite` + WAL/SHM files to `/tmp/` via `/bin/cp`
|
|
/// (bypasses the libswiftDarwin open() interpose), then open the copy with GRDB
|
|
/// read-only. The schema uses CoreData naming: `ZASSET` (assets), `ZGENERICALBUM`
|
|
/// (albums), `ZADDITIONALASSETATTRIBUTES` (filename + size), etc.
|
|
///
|
|
/// CoreData timestamps are seconds since January 1, 2001 (reference date).
|
|
///
|
|
/// ## Binary data: /bin/cat and /bin/cp subprocess workaround
|
|
///
|
|
/// libswiftDarwin DYLD-interposes `open(2)` across the entire Swift process. When
|
|
/// `photolibraryd` is active, `Darwin.open()`, `Data(contentsOf:)`, and `FileManager`
|
|
/// reads inside the Photos originals directory hang indefinitely. Spawning `/bin/cat`
|
|
/// (images) or `/bin/cp` (videos) as a native C subprocess bypasses this interpose.
|
|
/// `Darwin.access()` is not intercepted and is used for existence checks.
|
|
public final class PhotosLibraryReader: NSObject, @unchecked Sendable, PHPhotoLibraryChangeObserver {
|
|
public static let shared = PhotosLibraryReader()
|
|
|
|
private var authorizationStatus: PHAuthorizationStatus = .notDetermined
|
|
private var libraryReadyContinuation: CheckedContinuation<Void, Never>?
|
|
private let readyLock = NSLock()
|
|
private var libraryRegistered = false
|
|
|
|
private override init() {
|
|
super.init()
|
|
}
|
|
|
|
// MARK: - PHPhotoLibraryChangeObserver (unused but satisfies protocol)
|
|
|
|
public func photoLibraryDidChange(_ changeInstance: PHChange) {
|
|
readyLock.lock()
|
|
defer { readyLock.unlock() }
|
|
guard let cont = libraryReadyContinuation else { return }
|
|
libraryReadyContinuation = nil
|
|
cont.resume()
|
|
}
|
|
|
|
// MARK: - Authorization
|
|
|
|
/// Register with PHKit for TCC (so Photos access shows in System Settings),
|
|
/// then verify the originals directory is directly readable.
|
|
///
|
|
/// We do NOT use `PHAsset.fetchAssets` — see type-level documentation.
|
|
///
|
|
/// - Returns: `true` when the originals directory is directly readable.
|
|
public func requestAuthorization() async -> Bool {
|
|
let status = await withCheckedContinuation { continuation in
|
|
PHPhotoLibrary.requestAuthorization(for: .readWrite) { s in
|
|
continuation.resume(returning: s)
|
|
}
|
|
}
|
|
authorizationStatus = status
|
|
NSLog("PhotosReader: PHKit auth status=\(status.rawValue)")
|
|
if status == .denied || status == .restricted {
|
|
NSLog("PhotosReader: PHKit denied — file reads will use Full Disk Access path")
|
|
}
|
|
let accessible = isAccessible
|
|
NSLog("PhotosReader: direct library access=\(accessible)")
|
|
return accessible
|
|
}
|
|
|
|
/// Whether the originals directory is directly readable right now.
|
|
public var isAccessible: Bool {
|
|
Darwin.access(photosLibraryURL.appendingPathComponent("originals").path, F_OK) == 0
|
|
}
|
|
|
|
/// Diagnostic log of file access state. Fire-and-forget.
|
|
public func checkAccessibility() {
|
|
let path = photosLibraryURL.appendingPathComponent("originals").path
|
|
let ok = Darwin.access(path, F_OK) == 0
|
|
NSLog("PhotosReader: originals directory access(2)=\(ok)")
|
|
}
|
|
|
|
// MARK: - Metadata Fetch (direct SQLite)
|
|
|
|
/// Fetch photo assets by copying Photos.sqlite to temp and querying with GRDB.
|
|
public func fetchPhotos(since: Date? = nil) -> [PhotoAsset] {
|
|
guard let tempDB = copyPhotosDB() else {
|
|
NSLog("PhotosReader: could not copy Photos.sqlite — originals inaccessible or DB missing")
|
|
return []
|
|
}
|
|
defer { cleanupTempDB(tempDB) }
|
|
|
|
do {
|
|
var config = Configuration()
|
|
config.readonly = true
|
|
let queue = try DatabaseQueue(path: tempDB, configuration: config)
|
|
|
|
let assets: [PhotoAsset] = try queue.read { db in
|
|
var sql = """
|
|
SELECT
|
|
a.ZUUID,
|
|
a.ZKIND,
|
|
a.ZKINDSUBTYPE,
|
|
a.ZWIDTH,
|
|
a.ZHEIGHT,
|
|
a.ZDURATION,
|
|
a.ZDATECREATED,
|
|
a.ZMODIFICATIONDATE,
|
|
a.ZLATITUDE,
|
|
a.ZLONGITUDE,
|
|
a.ZFAVORITE,
|
|
a.ZHIDDEN,
|
|
a.ZAVALANCHEUUID,
|
|
attrs.ZORIGINALFILENAME,
|
|
attrs.ZORIGINALFILESIZE
|
|
FROM ZASSET a
|
|
LEFT JOIN ZADDITIONALASSETATTRIBUTES attrs ON attrs.ZASSET = a.Z_PK
|
|
WHERE a.ZTRASHEDSTATE = 0
|
|
"""
|
|
var args: [DatabaseValueConvertible] = []
|
|
|
|
if let since {
|
|
// CoreData reference date is Jan 1, 2001
|
|
let coredataSince = since.timeIntervalSinceReferenceDate
|
|
sql += " AND a.ZMODIFICATIONDATE > ?"
|
|
args.append(coredataSince)
|
|
}
|
|
|
|
sql += " ORDER BY a.ZDATECREATED DESC"
|
|
|
|
return try Row.fetchAll(db, sql: sql, arguments: StatementArguments(args)).map { row in
|
|
let uuid: String = row["ZUUID"] ?? UUID().uuidString
|
|
let kind: Int = row["ZKIND"] ?? 0
|
|
let subtype: Int = row["ZKINDSUBTYPE"] ?? 0
|
|
let width: Int = row["ZWIDTH"] ?? 0
|
|
let height: Int = row["ZHEIGHT"] ?? 0
|
|
let duration: Double = row["ZDURATION"] ?? 0
|
|
let createdTs: Double? = row["ZDATECREATED"]
|
|
let modifiedTs: Double? = row["ZMODIFICATIONDATE"]
|
|
let lat: Double? = row["ZLATITUDE"]
|
|
let lon: Double? = row["ZLONGITUDE"]
|
|
let favorite: Int = row["ZFAVORITE"] ?? 0
|
|
let hidden: Int = row["ZHIDDEN"] ?? 0
|
|
let avalanche: String? = row["ZAVALANCHEUUID"]
|
|
let filename: String? = row["ZORIGINALFILENAME"]
|
|
let fileSize: Int? = row["ZORIGINALFILESIZE"]
|
|
|
|
// -180.0 is Photos' sentinel for "no location"
|
|
let hasLocation = (lat != nil && lon != nil && lat! > -179.9 && lon! > -179.9)
|
|
|
|
return PhotoAsset(
|
|
localIdentifier: uuid + "/L0/001",
|
|
rawKind: kind,
|
|
rawSubtype: subtype,
|
|
width: width,
|
|
height: height,
|
|
fileSize: fileSize,
|
|
creationDate: createdTs.map { Date(timeIntervalSinceReferenceDate: $0) },
|
|
modificationDate: modifiedTs.map { Date(timeIntervalSinceReferenceDate: $0) },
|
|
latitude: hasLocation ? lat : nil,
|
|
longitude: hasLocation ? lon : nil,
|
|
isFavorite: favorite != 0,
|
|
isHidden: hidden != 0,
|
|
duration: duration,
|
|
burstIdentifier: avalanche,
|
|
originalFilename: filename
|
|
)
|
|
}
|
|
}
|
|
NSLog("PhotosReader: fetchPhotos count=\(assets.count) (SQLite)")
|
|
return assets
|
|
} catch {
|
|
NSLog("PhotosReader: fetchPhotos SQLite error: \(error)")
|
|
return []
|
|
}
|
|
}
|
|
|
|
/// Fetch user and smart albums from Photos.sqlite.
|
|
public func fetchAlbums() -> [PhotoAlbum] {
|
|
guard let tempDB = copyPhotosDB() else { return [] }
|
|
defer { cleanupTempDB(tempDB) }
|
|
|
|
do {
|
|
var config = Configuration()
|
|
config.readonly = true
|
|
let queue = try DatabaseQueue(path: tempDB, configuration: config)
|
|
|
|
return try queue.read { db in
|
|
// Get albums with non-zero asset counts
|
|
let albumRows = try Row.fetchAll(db, sql: """
|
|
SELECT
|
|
a.ZUUID,
|
|
a.ZTITLE,
|
|
a.ZTRASHEDSTATE,
|
|
a.ZCACHEDPHOTOSCOUNT,
|
|
a.ZCACHEDCOUNT,
|
|
a.ZSTARTDATE,
|
|
a.ZENDDATE,
|
|
a.ZCUSTOMKEYASSET,
|
|
a.ZPARENTFOLDER
|
|
FROM ZGENERICALBUM a
|
|
WHERE a.ZTRASHEDSTATE = 0
|
|
AND a.ZTITLE IS NOT NULL
|
|
ORDER BY a.ZTITLE ASC
|
|
""")
|
|
|
|
// Discover junction table once — CoreData generates Z_XXAssets per model version
|
|
guard let (jTable, albumCol, assetCol) = try discoverAlbumJunctionTable(db) else {
|
|
NSLog("PhotosReader: fetchAlbums — no junction table found, skipping album assets")
|
|
return []
|
|
}
|
|
|
|
var albums: [PhotoAlbum] = []
|
|
for row in albumRows {
|
|
guard let albumUUID: String = row["ZUUID"] else { continue }
|
|
let title: String = row["ZTITLE"] ?? "Untitled"
|
|
let startTs: Double? = row["ZSTARTDATE"]
|
|
let endTs: Double? = row["ZENDDATE"]
|
|
|
|
let assetRows = try Row.fetchAll(db, sql: """
|
|
SELECT ZUUID FROM ZASSET
|
|
WHERE ZASSET.Z_PK IN (
|
|
SELECT \(assetCol) FROM \(jTable)
|
|
WHERE \(albumCol) = (
|
|
SELECT Z_PK FROM ZGENERICALBUM WHERE ZUUID = ?
|
|
)
|
|
) AND ZTRASHEDSTATE = 0
|
|
""", arguments: [albumUUID])
|
|
|
|
let assetIds: [String] = assetRows.compactMap { r -> String? in
|
|
guard let uuid: String = r["ZUUID"] else { return nil }
|
|
return uuid + "/L0/001"
|
|
}
|
|
|
|
guard !assetIds.isEmpty else { continue }
|
|
|
|
albums.append(PhotoAlbum(
|
|
localIdentifier: albumUUID + "/L0/001",
|
|
title: title,
|
|
albumTypeString: "user",
|
|
startDate: startTs.map { Date(timeIntervalSinceReferenceDate: $0) },
|
|
endDate: endTs.map { Date(timeIntervalSinceReferenceDate: $0) },
|
|
assetLocalIdentifiers: assetIds
|
|
))
|
|
}
|
|
|
|
NSLog("PhotosReader: fetchAlbums count=\(albums.count) (SQLite)")
|
|
return albums
|
|
}
|
|
} catch {
|
|
NSLog("PhotosReader: fetchAlbums SQLite error: \(error)")
|
|
return []
|
|
}
|
|
}
|
|
|
|
// MARK: - File Location
|
|
|
|
/// Locate the original file for a given asset local identifier.
|
|
///
|
|
/// Photos stores originals at: `originals/<HEX-PREFIX>/<UUID>.<ext>`
|
|
/// Returns `nil` when the original has not been downloaded from iCloud.
|
|
public func findOriginalFile(uuid: String) -> URL? {
|
|
guard let first = uuid.first else { return nil }
|
|
let hexPrefix = String(first).uppercased()
|
|
let dirPath = photosLibraryURL
|
|
.appendingPathComponent("originals/\(hexPrefix)", isDirectory: true)
|
|
.path
|
|
let extensions = ["heic", "jpeg", "jpg", "heif", "mov", "mp4",
|
|
"png", "m4v", "tiff", "tif", "gif",
|
|
"dng", "raw", "cr2", "arw", "bmp"]
|
|
for ext in extensions {
|
|
let path = "\(dirPath)/\(uuid).\(ext)"
|
|
if Darwin.access(path, F_OK) == 0 {
|
|
return URL(fileURLWithPath: path)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// MARK: - Binary Data
|
|
|
|
/// Read image data for an asset via `/bin/cat` subprocess.
|
|
public func requestImageData(
|
|
localIdentifier: String,
|
|
completion: @escaping @Sendable (Data?, String?) -> Void
|
|
) {
|
|
let uuid = uuidFromLocalIdentifier(localIdentifier)
|
|
guard !uuid.isEmpty else { completion(nil, nil); return }
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async {
|
|
guard let fileURL = self.findOriginalFile(uuid: uuid) else {
|
|
NSLog("PhotosReader: original not locally available for \(uuid) — iCloud-only or deleted")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
let mimeType = Self.mimeType(fromExtension: fileURL.pathExtension)
|
|
NSLog("PhotosReader: /bin/cat reading \(fileURL.lastPathComponent)")
|
|
|
|
let task = Process()
|
|
task.executableURL = URL(fileURLWithPath: "/bin/cat")
|
|
task.arguments = [fileURL.path]
|
|
let outPipe = Pipe()
|
|
task.standardOutput = outPipe
|
|
task.standardError = Pipe()
|
|
|
|
do { try task.run() } catch {
|
|
NSLog("PhotosReader: /bin/cat launch failed for \(uuid): \(error)")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
let data = outPipe.fileHandleForReading.readDataToEndOfFile()
|
|
task.waitUntilExit()
|
|
|
|
guard task.terminationStatus == 0, !data.isEmpty else {
|
|
NSLog("PhotosReader: /bin/cat exit=\(task.terminationStatus) for \(uuid)")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
NSLog("PhotosReader: read \(data.count) bytes for \(uuid)")
|
|
completion(data, mimeType)
|
|
}
|
|
}
|
|
|
|
/// Copy a video asset to a temp location via `/bin/cp` subprocess.
|
|
public func requestVideoData(
|
|
localIdentifier: String,
|
|
completion: @escaping @Sendable (URL?, String?) -> Void
|
|
) {
|
|
let uuid = uuidFromLocalIdentifier(localIdentifier)
|
|
guard !uuid.isEmpty else { completion(nil, nil); return }
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async {
|
|
guard let fileURL = self.findOriginalFile(uuid: uuid) else {
|
|
NSLog("PhotosReader: video not locally available for \(uuid)")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
let mimeType = Self.mimeType(fromExtension: fileURL.pathExtension)
|
|
let tempURL = URL(fileURLWithPath: NSTemporaryDirectory())
|
|
.appendingPathComponent("\(uuid).\(fileURL.pathExtension)")
|
|
|
|
if let size = try? FileManager.default.attributesOfItem(atPath: tempURL.path)[.size] as? Int,
|
|
size > 0 {
|
|
completion(tempURL, mimeType)
|
|
return
|
|
}
|
|
|
|
let task = Process()
|
|
task.executableURL = URL(fileURLWithPath: "/bin/cp")
|
|
task.arguments = [fileURL.path, tempURL.path]
|
|
task.standardError = Pipe()
|
|
|
|
do {
|
|
try task.run()
|
|
task.waitUntilExit()
|
|
} catch {
|
|
NSLog("PhotosReader: /bin/cp failed for \(uuid): \(error)")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
guard task.terminationStatus == 0 else {
|
|
NSLog("PhotosReader: /bin/cp exit=\(task.terminationStatus) for \(uuid)")
|
|
completion(nil, nil)
|
|
return
|
|
}
|
|
|
|
NSLog("PhotosReader: video staged to temp for \(uuid)")
|
|
completion(tempURL, mimeType)
|
|
}
|
|
}
|
|
|
|
/// Remove any temp copy created by `requestVideoData`.
|
|
public func cleanupVideoTemp(localIdentifier: String) {
|
|
let uuid = uuidFromLocalIdentifier(localIdentifier)
|
|
guard !uuid.isEmpty else { return }
|
|
let tmpDir = URL(fileURLWithPath: NSTemporaryDirectory())
|
|
for ext in ["mov", "mp4", "m4v"] {
|
|
try? FileManager.default.removeItem(at: tmpDir.appendingPathComponent("\(uuid).\(ext)"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Auxiliary Metadata
|
|
|
|
/// File size (bytes) for an asset's original file, or `nil` if unavailable locally.
|
|
public func getAssetFileSize(localIdentifier: String) -> Int? {
|
|
let uuid = uuidFromLocalIdentifier(localIdentifier)
|
|
guard !uuid.isEmpty, let url = findOriginalFile(uuid: uuid) else { return nil }
|
|
return (try? FileManager.default.attributesOfItem(atPath: url.path)[.size] as? Int) ?? nil
|
|
}
|
|
|
|
/// Original filename for an asset (derived from file on disk, not DB).
|
|
public func getOriginalFilename(localIdentifier: String) -> String? {
|
|
let uuid = uuidFromLocalIdentifier(localIdentifier)
|
|
guard !uuid.isEmpty else { return nil }
|
|
return findOriginalFile(uuid: uuid)?.lastPathComponent
|
|
}
|
|
|
|
// MARK: - SQLite helpers
|
|
|
|
/// Discover the CoreData-generated album↔asset junction table name and its column names.
|
|
/// CoreData generates names like `Z_30ASSETS` where the number varies by model version.
|
|
/// Returns `(tableName, albumColumn, assetColumn)` or `nil` if not found.
|
|
private func discoverAlbumJunctionTable(_ db: Database) throws -> (String, String, String)? {
|
|
// Dynamic discovery — may miss tables only in the WAL, not yet checkpointed
|
|
var candidates = (try? String.fetchAll(db, sql: """
|
|
SELECT name FROM sqlite_master
|
|
WHERE type = 'table' AND name LIKE 'Z_%ASSETS'
|
|
ORDER BY name
|
|
""")) ?? []
|
|
|
|
// Fallback: probe known junction table names directly
|
|
// (sqlite_master may not show WAL-only tables in read-only mode)
|
|
if candidates.isEmpty {
|
|
for name in ["Z_30ASSETS", "Z_28ASSETS", "Z_29ASSETS", "Z_31ASSETS", "Z_32ASSETS"] {
|
|
if let rows = try? Row.fetchAll(db, sql: "PRAGMA table_info(\(name))"), !rows.isEmpty {
|
|
candidates = [name]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
for tableName in candidates {
|
|
guard let rows = try? Row.fetchAll(db, sql: "PRAGMA table_info(\(tableName))"),
|
|
!rows.isEmpty else { continue }
|
|
let colNames = rows.compactMap { r -> String? in r["name"] }
|
|
guard let albumCol = colNames.first(where: { $0.hasSuffix("ALBUMS") }),
|
|
let assetCol = colNames.first(where: { $0.hasSuffix("ASSETS") && !$0.hasPrefix("Z_FOK") })
|
|
else { continue }
|
|
return (tableName, albumCol, assetCol)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
/// Copy Photos.sqlite + WAL/SHM to a temp path so GRDB can open it without the
|
|
/// libswiftDarwin open() interpose blocking. Returns the temp DB path, or nil on failure.
|
|
private func copyPhotosDB() -> String? {
|
|
let dbPath = photosLibraryURL
|
|
.appendingPathComponent("database/Photos.sqlite").path
|
|
|
|
guard Darwin.access(dbPath, F_OK) == 0 else {
|
|
NSLog("PhotosReader: Photos.sqlite not accessible at \(dbPath)")
|
|
return nil
|
|
}
|
|
|
|
let tempDB = NSTemporaryDirectory() + "mac-sync-photos-\(ProcessInfo.processInfo.processIdentifier).sqlite"
|
|
|
|
func cpSubprocess(_ src: String, _ dst: String) -> Bool {
|
|
let t = Process()
|
|
t.executableURL = URL(fileURLWithPath: "/bin/cp")
|
|
t.arguments = [src, dst]
|
|
t.standardError = Pipe()
|
|
guard (try? t.run()) != nil else { return false }
|
|
t.waitUntilExit()
|
|
return t.terminationStatus == 0
|
|
}
|
|
|
|
guard cpSubprocess(dbPath, tempDB) else {
|
|
NSLog("PhotosReader: failed to copy Photos.sqlite")
|
|
return nil
|
|
}
|
|
|
|
// WAL mode: copy -wal and -shm so GRDB sees committed transactions
|
|
let walSrc = dbPath + "-wal"
|
|
let shmSrc = dbPath + "-shm"
|
|
if Darwin.access(walSrc, F_OK) == 0 { _ = cpSubprocess(walSrc, tempDB + "-wal") }
|
|
if Darwin.access(shmSrc, F_OK) == 0 { _ = cpSubprocess(shmSrc, tempDB + "-shm") }
|
|
|
|
return tempDB
|
|
}
|
|
|
|
private func cleanupTempDB(_ path: String) {
|
|
try? FileManager.default.removeItem(atPath: path)
|
|
try? FileManager.default.removeItem(atPath: path + "-wal")
|
|
try? FileManager.default.removeItem(atPath: path + "-shm")
|
|
}
|
|
|
|
// MARK: - Private helpers
|
|
|
|
private func uuidFromLocalIdentifier(_ localIdentifier: String) -> String {
|
|
localIdentifier.components(separatedBy: "/").first ?? ""
|
|
}
|
|
|
|
private var photosLibraryURL: URL {
|
|
FileManager.default.homeDirectoryForCurrentUser
|
|
.appendingPathComponent("Pictures/Photos Library.photoslibrary", isDirectory: true)
|
|
}
|
|
|
|
public static func mimeType(fromExtension ext: String) -> String {
|
|
switch ext.lowercased() {
|
|
case "jpg", "jpeg": return "image/jpeg"
|
|
case "png": return "image/png"
|
|
case "heic", "heif": return "image/heic"
|
|
case "gif": return "image/gif"
|
|
case "tiff", "tif": return "image/tiff"
|
|
case "mov": return "video/quicktime"
|
|
case "mp4", "m4v": return "video/mp4"
|
|
case "avi": return "video/avi"
|
|
case "dng": return "image/x-adobe-dng"
|
|
default: return "application/octet-stream"
|
|
}
|
|
}
|
|
}
|