mirror of
https://github.com/Dimillian/IceCubesApp.git
synced 2024-05-19 00:38:10 +00:00
948 lines
33 KiB
Swift
948 lines
33 KiB
Swift
import Combine
|
|
import DesignSystem
|
|
import Env
|
|
import Models
|
|
import NaturalLanguage
|
|
import Network
|
|
import PhotosUI
|
|
import SwiftUI
|
|
|
|
extension StatusEditor {
|
|
|
|
@MainActor
|
|
@Observable public class ViewModel: NSObject, Identifiable {
|
|
public let id = UUID()
|
|
|
|
var mode: Mode
|
|
|
|
var client: Client?
|
|
var currentAccount: Account? {
|
|
didSet {
|
|
if let itemsProvider {
|
|
mediaContainers = []
|
|
processItemsProvider(items: itemsProvider)
|
|
}
|
|
}
|
|
}
|
|
|
|
var theme: Theme?
|
|
var preferences: UserPreferences?
|
|
var languageConfirmationDialogLanguages: (detected: String, selected: String)?
|
|
|
|
var textView: UITextView? {
|
|
didSet {
|
|
textView?.pasteDelegate = self
|
|
}
|
|
}
|
|
|
|
var selectedRange: NSRange {
|
|
get {
|
|
guard let textView else {
|
|
return .init(location: 0, length: 0)
|
|
}
|
|
return textView.selectedRange
|
|
}
|
|
set {
|
|
textView?.selectedRange = newValue
|
|
}
|
|
}
|
|
|
|
var markedTextRange: UITextRange? {
|
|
guard let textView else {
|
|
return nil
|
|
}
|
|
return textView.markedTextRange
|
|
}
|
|
|
|
var statusText = NSMutableAttributedString(string: "") {
|
|
didSet {
|
|
let range = selectedRange
|
|
processText()
|
|
checkEmbed()
|
|
textView?.attributedText = statusText
|
|
selectedRange = range
|
|
}
|
|
}
|
|
|
|
private var urlLengthAdjustments: Int = 0
|
|
private let maxLengthOfUrl = 23
|
|
|
|
private var spoilerTextCount: Int {
|
|
spoilerOn ? spoilerText.utf16.count : 0
|
|
}
|
|
|
|
var statusTextCharacterLength: Int {
|
|
urlLengthAdjustments - statusText.string.utf16.count - spoilerTextCount
|
|
}
|
|
|
|
private var itemsProvider: [NSItemProvider]?
|
|
|
|
var backupStatusText: NSAttributedString?
|
|
|
|
var showPoll: Bool = false
|
|
var pollVotingFrequency = PollVotingFrequency.oneVote
|
|
var pollDuration = Duration.oneDay
|
|
var pollOptions: [String] = ["", ""]
|
|
|
|
var spoilerOn: Bool = false
|
|
var spoilerText: String = ""
|
|
|
|
var postingProgress: Double = 0.0
|
|
var postingTimer: Timer?
|
|
var isPosting: Bool = false
|
|
|
|
var mediaPickers: [PhotosPickerItem] = [] {
|
|
didSet {
|
|
if mediaPickers.count > 4 {
|
|
mediaPickers = mediaPickers.prefix(4).map { $0 }
|
|
}
|
|
|
|
let removedIDs = oldValue
|
|
.filter { !mediaPickers.contains($0) }
|
|
.compactMap(\.itemIdentifier)
|
|
mediaContainers.removeAll { removedIDs.contains($0.id) }
|
|
|
|
let newPickerItems = mediaPickers.filter { !oldValue.contains($0) }
|
|
if !newPickerItems.isEmpty {
|
|
isMediasLoading = true
|
|
for item in newPickerItems {
|
|
prepareToPost(for: item)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var isMediasLoading: Bool = false
|
|
|
|
var mediaContainers: [MediaContainer] = []
|
|
var replyToStatus: Status?
|
|
var embeddedStatus: Status?
|
|
|
|
var customEmojiContainer: [CategorizedEmojiContainer] = []
|
|
|
|
var postingError: String?
|
|
var showPostingErrorAlert: Bool = false
|
|
|
|
var canPost: Bool {
|
|
statusText.length > 0 || !mediaContainers.isEmpty
|
|
}
|
|
|
|
var shouldDisablePollButton: Bool {
|
|
!mediaContainers.isEmpty
|
|
}
|
|
|
|
var allMediaHasDescription: Bool {
|
|
var everyMediaHasAltText: Bool = true;
|
|
mediaContainers.forEach { mediaContainer in
|
|
if (((mediaContainer.mediaAttachment?.description) == nil) ||
|
|
mediaContainer.mediaAttachment?.description?.count == 0) {
|
|
everyMediaHasAltText = false
|
|
}
|
|
}
|
|
|
|
return everyMediaHasAltText;
|
|
}
|
|
|
|
var shouldDisplayDismissWarning: Bool {
|
|
var modifiedStatusText = statusText.string.trimmingCharacters(in: .whitespaces)
|
|
|
|
if let mentionString, modifiedStatusText.hasPrefix(mentionString) {
|
|
modifiedStatusText = String(modifiedStatusText.dropFirst(mentionString.count))
|
|
}
|
|
|
|
return !modifiedStatusText.isEmpty && !mode.isInShareExtension
|
|
}
|
|
|
|
var visibility: Models.Visibility = .pub
|
|
|
|
var mentionsSuggestions: [Account] = []
|
|
var tagsSuggestions: [Tag] = []
|
|
var showRecentsTagsInline: Bool = false
|
|
var selectedLanguage: String?
|
|
var hasExplicitlySelectedLanguage: Bool = false
|
|
private var currentSuggestionRange: NSRange?
|
|
|
|
private var embeddedStatusURL: URL? {
|
|
URL(string: embeddedStatus?.reblog?.url ?? embeddedStatus?.url ?? "")
|
|
}
|
|
|
|
private var mentionString: String?
|
|
|
|
private var suggestedTask: Task<Void, Never>?
|
|
|
|
init(mode: Mode) {
|
|
self.mode = mode
|
|
}
|
|
|
|
func setInitialLanguageSelection(preference: String?) {
|
|
switch mode {
|
|
case let .edit(status), let .quote(status):
|
|
selectedLanguage = status.language
|
|
default:
|
|
break
|
|
}
|
|
|
|
selectedLanguage = selectedLanguage ?? preference ?? currentAccount?.source?.language
|
|
}
|
|
|
|
func evaluateLanguages() {
|
|
if let detectedLang = detectLanguage(text: statusText.string),
|
|
let selectedLanguage,
|
|
selectedLanguage != "",
|
|
selectedLanguage != detectedLang
|
|
{
|
|
languageConfirmationDialogLanguages = (detected: detectedLang, selected: selectedLanguage)
|
|
} else {
|
|
languageConfirmationDialogLanguages = nil
|
|
}
|
|
}
|
|
|
|
func postStatus() async -> Status? {
|
|
guard let client else { return nil }
|
|
do {
|
|
if (!allMediaHasDescription && UserPreferences.shared.appRequireAltText) {
|
|
throw PostError.missingAltText
|
|
}
|
|
|
|
if postingTimer == nil {
|
|
Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { timer in
|
|
Task { @MainActor in
|
|
if self.postingProgress < 100 {
|
|
self.postingProgress += 0.5
|
|
}
|
|
if self.postingProgress >= 100 {
|
|
self.postingTimer?.invalidate()
|
|
self.postingTimer = nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
isPosting = true
|
|
let postStatus: Status?
|
|
var pollData: StatusData.PollData?
|
|
if let pollOptions = getPollOptionsForAPI() {
|
|
pollData = .init(options: pollOptions,
|
|
multiple: pollVotingFrequency.canVoteMultipleTimes,
|
|
expires_in: pollDuration.rawValue)
|
|
}
|
|
let data = StatusData(status: statusText.string,
|
|
visibility: visibility,
|
|
inReplyToId: mode.replyToStatus?.id,
|
|
spoilerText: spoilerOn ? spoilerText : nil,
|
|
mediaIds: mediaContainers.compactMap { $0.mediaAttachment?.id },
|
|
poll: pollData,
|
|
language: selectedLanguage,
|
|
mediaAttributes: mediaAttributes)
|
|
switch mode {
|
|
case .new, .replyTo, .quote, .mention, .shareExtension:
|
|
postStatus = try await client.post(endpoint: Statuses.postStatus(json: data))
|
|
if let postStatus {
|
|
StreamWatcher.shared.emmitPostEvent(for: postStatus)
|
|
}
|
|
case let .edit(status):
|
|
postStatus = try await client.put(endpoint: Statuses.editStatus(id: status.id, json: data))
|
|
if let postStatus {
|
|
StreamWatcher.shared.emmitEditEvent(for: postStatus)
|
|
}
|
|
}
|
|
|
|
postingTimer?.invalidate()
|
|
postingTimer = nil
|
|
|
|
withAnimation {
|
|
postingProgress = 99.0
|
|
}
|
|
try await Task.sleep(for: .seconds(0.5))
|
|
HapticManager.shared.fireHaptic(.notification(.success))
|
|
|
|
if hasExplicitlySelectedLanguage, let selectedLanguage {
|
|
preferences?.markLanguageAsSelected(isoCode: selectedLanguage)
|
|
}
|
|
isPosting = false
|
|
|
|
return postStatus
|
|
} catch {
|
|
if let error = error as? Models.ServerError {
|
|
postingError = error.error
|
|
showPostingErrorAlert = true
|
|
}
|
|
if let postError = error as? PostError {
|
|
postingError = postError.description
|
|
showPostingErrorAlert = true
|
|
}
|
|
isPosting = false
|
|
HapticManager.shared.fireHaptic(.notification(.error))
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// MARK: - Status Text manipulations
|
|
|
|
func insertStatusText(text: String) {
|
|
let string = statusText
|
|
string.mutableString.insert(text, at: selectedRange.location)
|
|
statusText = string
|
|
selectedRange = NSRange(location: selectedRange.location + text.utf16.count, length: 0)
|
|
processText()
|
|
}
|
|
|
|
func replaceTextWith(text: String, inRange: NSRange) {
|
|
let string = statusText
|
|
string.mutableString.deleteCharacters(in: inRange)
|
|
string.mutableString.insert(text, at: inRange.location)
|
|
statusText = string
|
|
selectedRange = NSRange(location: inRange.location + text.utf16.count, length: 0)
|
|
}
|
|
|
|
func replaceTextWith(text: String) {
|
|
statusText = .init(string: text)
|
|
selectedRange = .init(location: text.utf16.count, length: 0)
|
|
}
|
|
|
|
func prepareStatusText() {
|
|
switch mode {
|
|
case let .new(visibility):
|
|
self.visibility = visibility
|
|
case let .shareExtension(items):
|
|
itemsProvider = items
|
|
visibility = .pub
|
|
processItemsProvider(items: items)
|
|
case let .replyTo(status):
|
|
var mentionString = ""
|
|
if (status.reblog?.account.acct ?? status.account.acct) != currentAccount?.acct {
|
|
mentionString = "@\(status.reblog?.account.acct ?? status.account.acct)"
|
|
}
|
|
for mention in status.mentions where mention.acct != currentAccount?.acct {
|
|
if !mentionString.isEmpty {
|
|
mentionString += " "
|
|
}
|
|
mentionString += "@\(mention.acct)"
|
|
}
|
|
if !mentionString.isEmpty {
|
|
mentionString += " "
|
|
}
|
|
replyToStatus = status
|
|
visibility = UserPreferences.shared.getReplyVisibility(of: status)
|
|
statusText = .init(string: mentionString)
|
|
selectedRange = .init(location: mentionString.utf16.count, length: 0)
|
|
if !mentionString.isEmpty {
|
|
self.mentionString = mentionString.trimmingCharacters(in: .whitespaces)
|
|
}
|
|
if !status.spoilerText.asRawText.isEmpty {
|
|
spoilerOn = true
|
|
spoilerText = status.spoilerText.asRawText
|
|
}
|
|
case let .mention(account, visibility):
|
|
statusText = .init(string: "@\(account.acct) ")
|
|
self.visibility = visibility
|
|
selectedRange = .init(location: statusText.string.utf16.count, length: 0)
|
|
case let .edit(status):
|
|
var rawText = status.content.asRawText.escape()
|
|
for mention in status.mentions {
|
|
rawText = rawText.replacingOccurrences(of: "@\(mention.username)", with: "@\(mention.acct)")
|
|
}
|
|
statusText = .init(string: rawText)
|
|
selectedRange = .init(location: statusText.string.utf16.count, length: 0)
|
|
spoilerOn = !status.spoilerText.asRawText.isEmpty
|
|
spoilerText = status.spoilerText.asRawText
|
|
visibility = status.visibility
|
|
mediaContainers = status.mediaAttachments.map {
|
|
MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: $0,
|
|
error: nil
|
|
)
|
|
}
|
|
case let .quote(status):
|
|
embeddedStatus = status
|
|
if let url = embeddedStatusURL {
|
|
statusText = .init(string: "\n\nFrom: @\(status.reblog?.account.acct ?? status.account.acct)\n\(url)")
|
|
selectedRange = .init(location: 0, length: 0)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func processText() {
|
|
guard markedTextRange == nil else { return }
|
|
statusText.addAttributes([.foregroundColor: UIColor(Theme.shared.labelColor),
|
|
.font: Font.scaledBodyUIFont,
|
|
.backgroundColor: UIColor.clear,
|
|
.underlineColor: UIColor.clear],
|
|
range: NSMakeRange(0, statusText.string.utf16.count))
|
|
let hashtagPattern = "(#+[\\w0-9(_)]{0,})"
|
|
let mentionPattern = "(@+[a-zA-Z0-9(_).-]{1,})"
|
|
let urlPattern = "(?i)https?://(?:www\\.)?\\S+(?:/|\\b)"
|
|
|
|
do {
|
|
let hashtagRegex = try NSRegularExpression(pattern: hashtagPattern, options: [])
|
|
let mentionRegex = try NSRegularExpression(pattern: mentionPattern, options: [])
|
|
let urlRegex = try NSRegularExpression(pattern: urlPattern, options: [])
|
|
|
|
let range = NSMakeRange(0, statusText.string.utf16.count)
|
|
var ranges = hashtagRegex.matches(in: statusText.string,
|
|
options: [],
|
|
range: range).map(\.range)
|
|
ranges.append(contentsOf: mentionRegex.matches(in: statusText.string,
|
|
options: [],
|
|
range: range).map(\.range))
|
|
|
|
let urlRanges = urlRegex.matches(in: statusText.string,
|
|
options: [],
|
|
range: range).map(\.range)
|
|
|
|
var foundSuggestionRange = false
|
|
for nsRange in ranges {
|
|
statusText.addAttributes([.foregroundColor: UIColor(theme?.tintColor ?? .brand)],
|
|
range: nsRange)
|
|
if selectedRange.location == (nsRange.location + nsRange.length),
|
|
let range = Range(nsRange, in: statusText.string)
|
|
{
|
|
foundSuggestionRange = true
|
|
currentSuggestionRange = nsRange
|
|
loadAutoCompleteResults(query: String(statusText.string[range]))
|
|
}
|
|
}
|
|
|
|
if !foundSuggestionRange || ranges.isEmpty {
|
|
resetAutoCompletion()
|
|
}
|
|
|
|
var totalUrlLength = 0
|
|
var numUrls = 0
|
|
|
|
for range in urlRanges {
|
|
numUrls += 1
|
|
totalUrlLength += range.length
|
|
|
|
statusText.addAttributes([.foregroundColor: UIColor(theme?.tintColor ?? .brand),
|
|
.underlineStyle: NSUnderlineStyle.single.rawValue,
|
|
.underlineColor: UIColor(theme?.tintColor ?? .brand)],
|
|
range: NSRange(location: range.location, length: range.length))
|
|
}
|
|
|
|
urlLengthAdjustments = totalUrlLength - (maxLengthOfUrl * numUrls)
|
|
|
|
statusText.enumerateAttributes(in: range) { attributes, range, _ in
|
|
if attributes[.link] != nil {
|
|
statusText.removeAttribute(.link, range: range)
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
// MARK: - Shar sheet / Item provider
|
|
|
|
func processURLs(urls: [URL]) {
|
|
isMediasLoading = true
|
|
let items = urls.filter { $0.startAccessingSecurityScopedResource() }
|
|
.compactMap { NSItemProvider(contentsOf: $0) }
|
|
processItemsProvider(items: items)
|
|
}
|
|
|
|
func processGIFData(data: Data) {
|
|
isMediasLoading = true
|
|
let url = URL.temporaryDirectory.appending(path: "\(UUID().uuidString).gif")
|
|
try? data.write(to: url)
|
|
let container = MediaContainer(id: UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: .init(url: url),
|
|
mediaAttachment: nil,
|
|
error: nil)
|
|
prepareToPost(for: container)
|
|
}
|
|
|
|
func processCameraPhoto(image: UIImage) {
|
|
let container = MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: image,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
prepareToPost(for: container)
|
|
}
|
|
|
|
private func processItemsProvider(items: [NSItemProvider]) {
|
|
Task {
|
|
var initialText: String = ""
|
|
for item in items {
|
|
if let identifier = item.registeredTypeIdentifiers.first {
|
|
let handledItemType = UTTypeSupported(value: identifier)
|
|
do {
|
|
let compressor = Compressor()
|
|
let content = try await handledItemType.loadItemContent(item: item)
|
|
if let text = content as? String {
|
|
initialText += "\(text) "
|
|
} else if let image = content as? UIImage {
|
|
let container = MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: image,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
prepareToPost(for: container)
|
|
} else if let content = content as? ImageFileTranseferable,
|
|
let compressedData = await compressor.compressImageFrom(url: content.url),
|
|
let image = UIImage(data: compressedData)
|
|
{
|
|
let container = MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: image,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
prepareToPost(for: container)
|
|
} else if let video = content as? MovieFileTranseferable {
|
|
let container = MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: video,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
prepareToPost(for: container)
|
|
} else if let gif = content as? GifFileTranseferable {
|
|
let container = MediaContainer(
|
|
id: UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: gif,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
prepareToPost(for: container)
|
|
}
|
|
} catch {
|
|
isMediasLoading = false
|
|
}
|
|
}
|
|
}
|
|
if !initialText.isEmpty {
|
|
statusText = .init(string: initialText)
|
|
selectedRange = .init(location: statusText.string.utf16.count, length: 0)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Polls
|
|
|
|
func resetPollDefaults() {
|
|
pollOptions = ["", ""]
|
|
pollDuration = .oneDay
|
|
pollVotingFrequency = .oneVote
|
|
}
|
|
|
|
private func getPollOptionsForAPI() -> [String]? {
|
|
let options = pollOptions.filter { !$0.trimmingCharacters(in: .whitespaces).isEmpty }
|
|
return options.isEmpty ? nil : options
|
|
}
|
|
|
|
// MARK: - Embeds
|
|
|
|
private func checkEmbed() {
|
|
if let url = embeddedStatusURL,
|
|
!statusText.string.contains(url.absoluteString)
|
|
{
|
|
embeddedStatus = nil
|
|
mode = .new(visibility: visibility)
|
|
}
|
|
}
|
|
|
|
// MARK: - Autocomplete
|
|
|
|
private func loadAutoCompleteResults(query: String) {
|
|
guard let client else { return }
|
|
var query = query
|
|
suggestedTask?.cancel()
|
|
suggestedTask = Task {
|
|
do {
|
|
var results: SearchResults?
|
|
switch query.first {
|
|
case "#":
|
|
if query.utf8.count == 1 {
|
|
withAnimation {
|
|
showRecentsTagsInline = true
|
|
}
|
|
return
|
|
}
|
|
showRecentsTagsInline = false
|
|
query.removeFirst()
|
|
results = try await client.get(endpoint: Search.search(query: query,
|
|
type: "hashtags",
|
|
offset: 0,
|
|
following: nil),
|
|
forceVersion: .v2)
|
|
guard !Task.isCancelled else {
|
|
return
|
|
}
|
|
withAnimation {
|
|
tagsSuggestions = results?.hashtags.sorted(by: { $0.totalUses > $1.totalUses }) ?? []
|
|
}
|
|
case "@":
|
|
guard query.utf8.count > 1 else { return }
|
|
query.removeFirst()
|
|
let accounts: [Account] = try await client.get(endpoint: Search.accountsSearch(query: query,
|
|
type: nil,
|
|
offset: 0,
|
|
following: nil),
|
|
forceVersion: .v1)
|
|
guard !Task.isCancelled else {
|
|
return
|
|
}
|
|
withAnimation {
|
|
mentionsSuggestions = accounts
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
private func resetAutoCompletion() {
|
|
if !tagsSuggestions.isEmpty ||
|
|
!mentionsSuggestions.isEmpty ||
|
|
currentSuggestionRange != nil ||
|
|
showRecentsTagsInline {
|
|
withAnimation {
|
|
tagsSuggestions = []
|
|
mentionsSuggestions = []
|
|
currentSuggestionRange = nil
|
|
showRecentsTagsInline = false
|
|
}
|
|
}
|
|
}
|
|
|
|
func selectMentionSuggestion(account: Account) {
|
|
if let range = currentSuggestionRange {
|
|
replaceTextWith(text: "@\(account.acct) ", inRange: range)
|
|
}
|
|
}
|
|
|
|
func selectHashtagSuggestion(tag: String) {
|
|
if let range = currentSuggestionRange {
|
|
replaceTextWith(text: "#\(tag) ", inRange: range)
|
|
}
|
|
}
|
|
|
|
// MARK: - OpenAI Prompt
|
|
|
|
func runOpenAI(prompt: OpenAIClient.Prompt) async {
|
|
do {
|
|
let client = OpenAIClient()
|
|
let response = try await client.request(prompt)
|
|
backupStatusText = statusText
|
|
replaceTextWith(text: response.trimmedText)
|
|
} catch {}
|
|
}
|
|
|
|
// MARK: - Media related function
|
|
|
|
private func indexOf(container: MediaContainer) -> Int? {
|
|
mediaContainers.firstIndex(where: { $0.id == container.id })
|
|
}
|
|
|
|
func prepareToPost(for pickerItem: PhotosPickerItem) {
|
|
Task(priority: .high) {
|
|
if let container = await makeMediaContainer(from: pickerItem) {
|
|
self.mediaContainers.append(container)
|
|
await upload(container: container)
|
|
self.isMediasLoading = false
|
|
}
|
|
}
|
|
}
|
|
|
|
func prepareToPost(for container: MediaContainer) {
|
|
Task(priority: .high) {
|
|
self.mediaContainers.append(container)
|
|
await upload(container: container)
|
|
self.isMediasLoading = false
|
|
}
|
|
}
|
|
|
|
nonisolated func makeMediaContainer(from pickerItem: PhotosPickerItem) async -> MediaContainer? {
|
|
await withTaskGroup(of: MediaContainer?.self, returning: MediaContainer?.self) { taskGroup in
|
|
taskGroup.addTask(priority: .high) { await Self.makeImageContainer(from: pickerItem) }
|
|
taskGroup.addTask(priority: .high) { await Self.makeGifContainer(from: pickerItem) }
|
|
taskGroup.addTask(priority: .high) { await Self.makeMovieContainer(from: pickerItem) }
|
|
|
|
for await container in taskGroup {
|
|
if let container {
|
|
taskGroup.cancelAll()
|
|
return container
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func makeGifContainer(from pickerItem: PhotosPickerItem) async -> MediaContainer? {
|
|
guard let gifFile = try? await pickerItem.loadTransferable(type: GifFileTranseferable.self) else { return nil }
|
|
|
|
return MediaContainer(
|
|
id: pickerItem.itemIdentifier ?? UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: gifFile,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
}
|
|
|
|
private static func makeMovieContainer(from pickerItem: PhotosPickerItem) async -> MediaContainer? {
|
|
guard let movieFile = try? await pickerItem.loadTransferable(type: MovieFileTranseferable.self) else { return nil }
|
|
|
|
return MediaContainer(
|
|
id: pickerItem.itemIdentifier ?? UUID().uuidString,
|
|
image: nil,
|
|
movieTransferable: movieFile,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
}
|
|
|
|
private static func makeImageContainer(from pickerItem: PhotosPickerItem) async -> MediaContainer? {
|
|
guard let imageFile = try? await pickerItem.loadTransferable(type: ImageFileTranseferable.self) else { return nil }
|
|
|
|
let compressor = Compressor()
|
|
|
|
guard let compressedData = await compressor.compressImageFrom(url: imageFile.url),
|
|
let image = UIImage(data: compressedData)
|
|
else { return nil }
|
|
|
|
return MediaContainer(
|
|
id: pickerItem.itemIdentifier ?? UUID().uuidString,
|
|
image: image,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
}
|
|
|
|
func upload(container: MediaContainer) async {
|
|
if let index = indexOf(container: container) {
|
|
let originalContainer = mediaContainers[index]
|
|
guard originalContainer.mediaAttachment == nil else { return }
|
|
let newContainer = MediaContainer(
|
|
id: originalContainer.id,
|
|
image: originalContainer.image,
|
|
movieTransferable: originalContainer.movieTransferable,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: nil
|
|
)
|
|
mediaContainers[index] = newContainer
|
|
do {
|
|
let compressor = Compressor()
|
|
if let image = originalContainer.image {
|
|
let imageData = try await compressor.compressImageForUpload(image)
|
|
let uploadedMedia = try await uploadMedia(data: imageData, mimeType: "image/jpeg")
|
|
if let index = indexOf(container: newContainer) {
|
|
mediaContainers[index] = MediaContainer(
|
|
id: originalContainer.id,
|
|
image: mode.isInShareExtension ? originalContainer.image : nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: uploadedMedia,
|
|
error: nil
|
|
)
|
|
}
|
|
if let uploadedMedia, uploadedMedia.url == nil {
|
|
scheduleAsyncMediaRefresh(mediaAttachement: uploadedMedia)
|
|
}
|
|
} else if let videoURL = originalContainer.movieTransferable?.url,
|
|
let compressedVideoURL = await compressor.compressVideo(videoURL),
|
|
let data = try? Data(contentsOf: compressedVideoURL)
|
|
{
|
|
let uploadedMedia = try await uploadMedia(data: data, mimeType: compressedVideoURL.mimeType())
|
|
if let index = indexOf(container: newContainer) {
|
|
mediaContainers[index] = MediaContainer(
|
|
id: originalContainer.id,
|
|
image: mode.isInShareExtension ? originalContainer.image : nil,
|
|
movieTransferable: originalContainer.movieTransferable,
|
|
gifTransferable: nil,
|
|
mediaAttachment: uploadedMedia,
|
|
error: nil
|
|
)
|
|
}
|
|
if let uploadedMedia, uploadedMedia.url == nil {
|
|
scheduleAsyncMediaRefresh(mediaAttachement: uploadedMedia)
|
|
}
|
|
} else if let gifData = originalContainer.gifTransferable?.data {
|
|
let uploadedMedia = try await uploadMedia(data: gifData, mimeType: "image/gif")
|
|
if let index = indexOf(container: newContainer) {
|
|
mediaContainers[index] = MediaContainer(
|
|
id: originalContainer.id,
|
|
image: mode.isInShareExtension ? originalContainer.image : nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: originalContainer.gifTransferable,
|
|
mediaAttachment: uploadedMedia,
|
|
error: nil
|
|
)
|
|
}
|
|
if let uploadedMedia, uploadedMedia.url == nil {
|
|
scheduleAsyncMediaRefresh(mediaAttachement: uploadedMedia)
|
|
}
|
|
}
|
|
} catch {
|
|
if let index = indexOf(container: newContainer) {
|
|
mediaContainers[index] = MediaContainer(
|
|
id: originalContainer.id,
|
|
image: originalContainer.image,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: nil,
|
|
error: error
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func scheduleAsyncMediaRefresh(mediaAttachement: MediaAttachment) {
|
|
Task {
|
|
repeat {
|
|
if let client,
|
|
let index = mediaContainers.firstIndex(where: { $0.mediaAttachment?.id == mediaAttachement.id })
|
|
{
|
|
guard mediaContainers[index].mediaAttachment?.url == nil else {
|
|
return
|
|
}
|
|
do {
|
|
let newAttachement: MediaAttachment = try await client.get(endpoint: Media.media(id: mediaAttachement.id,
|
|
json: nil))
|
|
if newAttachement.url != nil {
|
|
let oldContainer = mediaContainers[index]
|
|
mediaContainers[index] = MediaContainer(
|
|
id: mediaAttachement.id,
|
|
image: oldContainer.image,
|
|
movieTransferable: oldContainer.movieTransferable,
|
|
gifTransferable: oldContainer.gifTransferable,
|
|
mediaAttachment: newAttachement,
|
|
error: nil
|
|
)
|
|
}
|
|
} catch {
|
|
print(error.localizedDescription)
|
|
}
|
|
}
|
|
try? await Task.sleep(for: .seconds(5))
|
|
} while !Task.isCancelled
|
|
}
|
|
}
|
|
|
|
func addDescription(container: MediaContainer, description: String) async {
|
|
guard let client, let attachment = container.mediaAttachment else { return }
|
|
if let index = indexOf(container: container) {
|
|
do {
|
|
let media: MediaAttachment = try await client.put(endpoint: Media.media(id: attachment.id,
|
|
json: .init(description: description)))
|
|
mediaContainers[index] = MediaContainer(
|
|
id: container.id,
|
|
image: nil,
|
|
movieTransferable: nil,
|
|
gifTransferable: nil,
|
|
mediaAttachment: media,
|
|
error: nil
|
|
)
|
|
} catch { print(error) }
|
|
}
|
|
}
|
|
|
|
private var mediaAttributes: [StatusData.MediaAttribute] = []
|
|
func editDescription(container: MediaContainer, description: String) async {
|
|
guard let attachment = container.mediaAttachment else { return }
|
|
if indexOf(container: container) != nil {
|
|
mediaAttributes.append(StatusData.MediaAttribute(id: attachment.id, description: description, thumbnail: nil, focus: nil))
|
|
}
|
|
}
|
|
|
|
private func uploadMedia(data: Data, mimeType: String) async throws -> MediaAttachment? {
|
|
guard let client else { return nil }
|
|
return try await client.mediaUpload(endpoint: Media.medias,
|
|
version: .v2,
|
|
method: "POST",
|
|
mimeType: mimeType,
|
|
filename: "file",
|
|
data: data)
|
|
}
|
|
|
|
// MARK: - Custom emojis
|
|
|
|
func fetchCustomEmojis() async {
|
|
typealias EmojiContainer = CategorizedEmojiContainer
|
|
|
|
guard let client else { return }
|
|
do {
|
|
let customEmojis: [Emoji] = try await client.get(endpoint: CustomEmojis.customEmojis) ?? []
|
|
var emojiContainers: [EmojiContainer] = []
|
|
|
|
customEmojis.reduce([String: [Emoji]]()) { currentDict, emoji in
|
|
var dict = currentDict
|
|
let category = emoji.category ?? "Custom"
|
|
|
|
if let emojis = dict[category] {
|
|
dict[category] = emojis + [emoji]
|
|
} else {
|
|
dict[category] = [emoji]
|
|
}
|
|
|
|
return dict
|
|
}.sorted(by: { lhs, rhs in
|
|
if rhs.key == "Custom" { false }
|
|
else if lhs.key == "Custom" { true }
|
|
else { lhs.key < rhs.key }
|
|
}).forEach { key, value in
|
|
emojiContainers.append(.init(categoryName: key, emojis: value))
|
|
}
|
|
|
|
customEmojiContainer = emojiContainers
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - DropDelegate
|
|
|
|
extension StatusEditor.ViewModel: DropDelegate {
|
|
public func performDrop(info: DropInfo) -> Bool {
|
|
let item = info.itemProviders(for: [.image, .video, .gif, .mpeg4Movie, .quickTimeMovie, .movie])
|
|
processItemsProvider(items: item)
|
|
return true
|
|
}
|
|
}
|
|
|
|
// MARK: - UITextPasteDelegate
|
|
|
|
extension StatusEditor.ViewModel: UITextPasteDelegate {
|
|
public func textPasteConfigurationSupporting(
|
|
_: UITextPasteConfigurationSupporting,
|
|
transform item: UITextPasteItem
|
|
) {
|
|
if !item.itemProvider.registeredContentTypes(conformingTo: .image).isEmpty ||
|
|
!item.itemProvider.registeredContentTypes(conformingTo: .video).isEmpty ||
|
|
!item.itemProvider.registeredContentTypes(conformingTo: .gif).isEmpty
|
|
{
|
|
processItemsProvider(items: [item.itemProvider])
|
|
item.setNoResult()
|
|
} else {
|
|
item.setDefaultResult()
|
|
}
|
|
}
|
|
}
|
|
|
|
extension PhotosPickerItem: @unchecked Sendable {}
|