116 lines
4.5 KiB
Swift
116 lines
4.5 KiB
Swift
//
|
|
// DraftAttachment.swift
|
|
// ComposeUI
|
|
//
|
|
// Created by Shadowfacts on 3/14/20.
|
|
// Copyright © 2020 Shadowfacts. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
import UIKit
|
|
import UniformTypeIdentifiers
|
|
|
|
public final class DraftAttachment: NSObject, Codable, ObservableObject, Identifiable {
|
|
static let typeIdentifier = "space.vaccor.Tusker.composition-attachment"
|
|
|
|
public let id: UUID
|
|
@Published var data: AttachmentData
|
|
@Published var attachmentDescription: String
|
|
|
|
init(data: AttachmentData, description: String = "") {
|
|
self.id = UUID()
|
|
self.data = data
|
|
self.attachmentDescription = description
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
|
|
self.id = try container.decode(UUID.self, forKey: .id)
|
|
self.data = try container.decode(AttachmentData.self, forKey: .data)
|
|
self.attachmentDescription = try container.decode(String.self, forKey: .attachmentDescription)
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
|
|
try container.encode(id, forKey: .id)
|
|
try container.encode(data, forKey: .data)
|
|
try container.encode(attachmentDescription, forKey: .attachmentDescription)
|
|
}
|
|
|
|
static func ==(lhs: DraftAttachment, rhs: DraftAttachment) -> Bool {
|
|
return lhs.id == rhs.id
|
|
}
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case id
|
|
case data
|
|
case attachmentDescription
|
|
}
|
|
}
|
|
|
|
private let jpegType = UTType.jpeg.identifier
|
|
private let pngType = UTType.png.identifier
|
|
private let mp4Type = UTType.mpeg4Movie.identifier
|
|
private let quickTimeType = UTType.quickTimeMovie.identifier
|
|
private let gifType = UTType.gif.identifier
|
|
|
|
extension DraftAttachment: NSItemProviderWriting {
|
|
public static var writableTypeIdentifiersForItemProvider: [String] {
|
|
[typeIdentifier]
|
|
}
|
|
|
|
public func loadData(withTypeIdentifier typeIdentifier: String, forItemProviderCompletionHandler completionHandler: @escaping (Data?, Error?) -> Void) -> Progress? {
|
|
if typeIdentifier == DraftAttachment.typeIdentifier {
|
|
do {
|
|
completionHandler(try PropertyListEncoder().encode(self), nil)
|
|
} catch {
|
|
completionHandler(nil, error)
|
|
}
|
|
} else {
|
|
completionHandler(nil, ItemProviderError.incompatibleTypeIdentifier)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
enum ItemProviderError: Error {
|
|
case incompatibleTypeIdentifier
|
|
|
|
var localizedDescription: String {
|
|
switch self {
|
|
case .incompatibleTypeIdentifier:
|
|
return "Cannot provide data for given type"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extension DraftAttachment: NSItemProviderReading {
|
|
public static var readableTypeIdentifiersForItemProvider: [String] {
|
|
// todo: is there a better way of handling movies than manually adding all possible UTI types?
|
|
// just using kUTTypeMovie doesn't work, because we need the actually type in order to get the file extension
|
|
// without the file extension, getting the thumbnail and exporting the video for attachment upload fails
|
|
[typeIdentifier, gifType, jpegType, pngType, mp4Type, quickTimeType]
|
|
}
|
|
|
|
public static func object(withItemProviderData data: Data, typeIdentifier: String) throws -> DraftAttachment {
|
|
if typeIdentifier == DraftAttachment.typeIdentifier {
|
|
return try PropertyListDecoder().decode(DraftAttachment.self, from: data)
|
|
} else if typeIdentifier == gifType {
|
|
return DraftAttachment(data: .gif(data))
|
|
} else if UIImage.readableTypeIdentifiersForItemProvider.contains(typeIdentifier) {
|
|
return DraftAttachment(data: .image(data, originalType: UTType(typeIdentifier)!))
|
|
} else if typeIdentifier == mp4Type || typeIdentifier == quickTimeType {
|
|
let temporaryDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
|
|
let temporaryFileName = ProcessInfo().globallyUniqueString
|
|
let fileExt = UTType(typeIdentifier)!.preferredFilenameExtension!
|
|
let temporaryFileURL = temporaryDirectoryURL.appendingPathComponent(temporaryFileName).appendingPathExtension(fileExt)
|
|
try data.write(to: temporaryFileURL)
|
|
return DraftAttachment(data: .video(temporaryFileURL))
|
|
} else {
|
|
throw ItemProviderError.incompatibleTypeIdentifier
|
|
}
|
|
}
|
|
}
|