forked from zelo72/mastodon-ios
403 lines
16 KiB
Swift
403 lines
16 KiB
Swift
//
|
|
// ShareViewModel.swift
|
|
// MastodonShareAction
|
|
//
|
|
// Created by MainasuK Cirno on 2021-7-16.
|
|
//
|
|
|
|
import os.log
|
|
import Foundation
|
|
import Combine
|
|
import CoreData
|
|
import CoreDataStack
|
|
import MastodonSDK
|
|
import MastodonUI
|
|
import SwiftUI
|
|
import UniformTypeIdentifiers
|
|
import MastodonAsset
|
|
import MastodonLocalization
|
|
import MastodonUI
|
|
|
|
final class ShareViewModel {
|
|
|
|
let logger = Logger(subsystem: "ShareViewModel", category: "logic")
|
|
|
|
var disposeBag = Set<AnyCancellable>()
|
|
|
|
static let composeContentLimit: Int = 500
|
|
|
|
// input
|
|
private var coreDataStack: CoreDataStack?
|
|
var managedObjectContext: NSManagedObjectContext?
|
|
var inputItems = CurrentValueSubject<[NSExtensionItem], Never>([])
|
|
let viewDidAppear = CurrentValueSubject<Bool, Never>(false)
|
|
let traitCollectionDidChangePublisher = CurrentValueSubject<Void, Never>(Void()) // use CurrentValueSubject to make initial event emit
|
|
let selectedStatusVisibility = CurrentValueSubject<ComposeToolbarView.VisibilitySelectionType, Never>(.public)
|
|
|
|
// output
|
|
let authentication = CurrentValueSubject<Result<MastodonAuthentication, Error>?, Never>(nil)
|
|
let isFetchAuthentication = CurrentValueSubject<Bool, Never>(true)
|
|
let isPublishing = CurrentValueSubject<Bool, Never>(false)
|
|
let isBusy = CurrentValueSubject<Bool, Never>(true)
|
|
let isValid = CurrentValueSubject<Bool, Never>(false)
|
|
let shouldDismiss = CurrentValueSubject<Bool, Never>(true)
|
|
let composeViewModel = ComposeViewModel()
|
|
let characterCount = CurrentValueSubject<Int, Never>(0)
|
|
|
|
init() {
|
|
viewDidAppear.receive(on: DispatchQueue.main)
|
|
.removeDuplicates()
|
|
.sink { [weak self] viewDidAppear in
|
|
guard let self = self else { return }
|
|
guard viewDidAppear else { return }
|
|
self.setupCoreData()
|
|
}
|
|
.store(in: &disposeBag)
|
|
|
|
Publishers.CombineLatest(
|
|
inputItems.removeDuplicates(),
|
|
viewDidAppear.removeDuplicates()
|
|
)
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { [weak self] inputItems, _ in
|
|
guard let self = self else { return }
|
|
self.parse(inputItems: inputItems)
|
|
}
|
|
.store(in: &disposeBag)
|
|
|
|
// bind authentication loading state
|
|
authentication
|
|
.map { result in result == nil }
|
|
.assign(to: \.value, on: isFetchAuthentication)
|
|
.store(in: &disposeBag)
|
|
|
|
// bind user locked state
|
|
authentication
|
|
.compactMap { result -> Bool? in
|
|
guard let result = result else { return nil }
|
|
switch result {
|
|
case .success(let authentication):
|
|
return authentication.user.locked
|
|
case .failure:
|
|
return nil
|
|
}
|
|
}
|
|
.map { locked -> ComposeToolbarView.VisibilitySelectionType in
|
|
locked ? .private : .public
|
|
}
|
|
.assign(to: \.value, on: selectedStatusVisibility)
|
|
.store(in: &disposeBag)
|
|
|
|
// bind author
|
|
authentication
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { [weak self] result in
|
|
guard let self = self else { return }
|
|
guard let result = result else { return }
|
|
switch result {
|
|
case .success(let authentication):
|
|
self.composeViewModel.avatarImageURL = authentication.user.avatarImageURL()
|
|
self.composeViewModel.authorName = authentication.user.displayNameWithFallback
|
|
self.composeViewModel.authorUsername = "@" + authentication.user.username
|
|
case .failure:
|
|
self.composeViewModel.avatarImageURL = nil
|
|
self.composeViewModel.authorName = " "
|
|
self.composeViewModel.authorUsername = " "
|
|
}
|
|
}
|
|
.store(in: &disposeBag)
|
|
|
|
// bind authentication to compose view model
|
|
authentication
|
|
.map { result -> MastodonAuthentication? in
|
|
guard let result = result else { return nil }
|
|
switch result {
|
|
case .success(let authentication):
|
|
return authentication
|
|
case .failure:
|
|
return nil
|
|
}
|
|
}
|
|
.assign(to: &composeViewModel.$authentication)
|
|
|
|
// bind isBusy
|
|
Publishers.CombineLatest(
|
|
isFetchAuthentication,
|
|
isPublishing
|
|
)
|
|
.receive(on: DispatchQueue.main)
|
|
.map { $0 || $1 }
|
|
.assign(to: \.value, on: isBusy)
|
|
.store(in: &disposeBag)
|
|
|
|
// pass initial i18n string
|
|
composeViewModel.statusPlaceholder = L10n.Scene.Compose.contentInputPlaceholder
|
|
composeViewModel.contentWarningPlaceholder = L10n.Scene.Compose.ContentWarning.placeholder
|
|
composeViewModel.toolbarHeight = ComposeToolbarView.toolbarHeight
|
|
|
|
// bind compose bar button item UI state
|
|
let isComposeContentEmpty = composeViewModel.$statusContent
|
|
.map { $0.isEmpty }
|
|
|
|
isComposeContentEmpty
|
|
.assign(to: \.value, on: shouldDismiss)
|
|
.store(in: &disposeBag)
|
|
|
|
let isComposeContentValid = composeViewModel.$characterCount
|
|
.map { characterCount -> Bool in
|
|
return characterCount <= ShareViewModel.composeContentLimit
|
|
}
|
|
let isMediaEmpty = composeViewModel.$attachmentViewModels
|
|
.map { $0.isEmpty }
|
|
let isMediaUploadAllSuccess = composeViewModel.$attachmentViewModels
|
|
.map { viewModels in
|
|
viewModels.allSatisfy { $0.uploadStateMachineSubject.value is StatusAttachmentViewModel.UploadState.Finish }
|
|
}
|
|
|
|
let isPublishBarButtonItemEnabledPrecondition1 = Publishers.CombineLatest4(
|
|
isComposeContentEmpty,
|
|
isComposeContentValid,
|
|
isMediaEmpty,
|
|
isMediaUploadAllSuccess
|
|
)
|
|
.map { isComposeContentEmpty, isComposeContentValid, isMediaEmpty, isMediaUploadAllSuccess -> Bool in
|
|
if isMediaEmpty {
|
|
return isComposeContentValid && !isComposeContentEmpty
|
|
} else {
|
|
return isComposeContentValid && isMediaUploadAllSuccess
|
|
}
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
let isPublishBarButtonItemEnabledPrecondition2 = Publishers.CombineLatest(
|
|
isComposeContentEmpty,
|
|
isComposeContentValid
|
|
)
|
|
.map { isComposeContentEmpty, isComposeContentValid -> Bool in
|
|
return isComposeContentValid && !isComposeContentEmpty
|
|
}
|
|
.eraseToAnyPublisher()
|
|
|
|
Publishers.CombineLatest(
|
|
isPublishBarButtonItemEnabledPrecondition1,
|
|
isPublishBarButtonItemEnabledPrecondition2
|
|
)
|
|
.map { $0 && $1 }
|
|
.assign(to: \.value, on: isValid)
|
|
.store(in: &disposeBag)
|
|
|
|
// bind counter
|
|
composeViewModel.$characterCount
|
|
.assign(to: \.value, on: characterCount)
|
|
.store(in: &disposeBag)
|
|
|
|
// setup theme
|
|
setupBackgroundColor(theme: ThemeService.shared.currentTheme.value)
|
|
ThemeService.shared.currentTheme
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { [weak self] theme in
|
|
guard let self = self else { return }
|
|
self.setupBackgroundColor(theme: theme)
|
|
}
|
|
.store(in: &disposeBag)
|
|
}
|
|
|
|
private func setupBackgroundColor(theme: Theme) {
|
|
composeViewModel.contentWarningBackgroundColor = Color(theme.contentWarningOverlayBackgroundColor)
|
|
}
|
|
|
|
}
|
|
|
|
extension ShareViewModel {
|
|
enum ShareError: Error {
|
|
case `internal`(error: Error)
|
|
case userCancelShare
|
|
case missingAuthentication
|
|
}
|
|
}
|
|
|
|
extension ShareViewModel {
|
|
private func setupCoreData() {
|
|
logger.debug("\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public)")
|
|
DispatchQueue.global().async {
|
|
let _coreDataStack = CoreDataStack()
|
|
self.coreDataStack = _coreDataStack
|
|
self.managedObjectContext = _coreDataStack.persistentContainer.viewContext
|
|
|
|
_coreDataStack.didFinishLoad
|
|
.receive(on: RunLoop.main)
|
|
.sink { [weak self] didFinishLoad in
|
|
guard let self = self else { return }
|
|
guard didFinishLoad else { return }
|
|
guard let managedObjectContext = self.managedObjectContext else { return }
|
|
|
|
self.logger.debug("\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): fetch authentication…")
|
|
managedObjectContext.perform {
|
|
do {
|
|
let request = MastodonAuthentication.sortedFetchRequest
|
|
let authentications = try managedObjectContext.fetch(request)
|
|
let authentication = authentications.sorted(by: { $0.activedAt > $1.activedAt }).first
|
|
guard let activeAuthentication = authentication else {
|
|
self.authentication.value = .failure(ShareError.missingAuthentication)
|
|
return
|
|
}
|
|
self.authentication.value = .success(activeAuthentication)
|
|
self.logger.debug("\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): fetch authentication success \(activeAuthentication.userID)")
|
|
} catch {
|
|
self.authentication.value = .failure(ShareError.internal(error: error))
|
|
self.logger.debug("\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): fetch authentication fail \(error.localizedDescription)")
|
|
assertionFailure(error.localizedDescription)
|
|
}
|
|
}
|
|
}
|
|
.store(in: &self.disposeBag)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ShareViewModel {
|
|
func parse(inputItems: [NSExtensionItem]) {
|
|
var itemProviders: [NSItemProvider] = []
|
|
|
|
for item in inputItems {
|
|
itemProviders.append(contentsOf: item.attachments ?? [])
|
|
}
|
|
|
|
let _textProvider = itemProviders.first { provider in
|
|
return provider.hasRepresentationConforming(toTypeIdentifier: UTType.plainText.identifier, fileOptions: [])
|
|
}
|
|
|
|
let _urlProvider = itemProviders.first { provider in
|
|
return provider.hasRepresentationConforming(toTypeIdentifier: UTType.url.identifier, fileOptions: [])
|
|
}
|
|
|
|
let _movieProvider = itemProviders.first { provider in
|
|
return provider.hasRepresentationConforming(toTypeIdentifier: UTType.movie.identifier, fileOptions: [])
|
|
}
|
|
|
|
let imageProviders = itemProviders.filter { provider in
|
|
return provider.hasRepresentationConforming(toTypeIdentifier: UTType.image.identifier, fileOptions: [])
|
|
}
|
|
|
|
Task { @MainActor in
|
|
async let text = ShareViewModel.loadText(textProvider: _textProvider)
|
|
async let url = ShareViewModel.loadURL(textProvider: _urlProvider)
|
|
|
|
let content = await [text, url]
|
|
.compactMap { $0 }
|
|
.joined(separator: " ")
|
|
self.composeViewModel.statusContent = content
|
|
}
|
|
|
|
if let movieProvider = _movieProvider {
|
|
composeViewModel.setupAttachmentViewModels([
|
|
StatusAttachmentViewModel(itemProvider: movieProvider)
|
|
])
|
|
} else if !imageProviders.isEmpty {
|
|
let viewModels = imageProviders.map { provider in
|
|
StatusAttachmentViewModel(itemProvider: provider)
|
|
}
|
|
composeViewModel.setupAttachmentViewModels(viewModels)
|
|
}
|
|
|
|
}
|
|
|
|
private static func loadText(textProvider: NSItemProvider?) async -> String? {
|
|
guard let textProvider = textProvider else { return nil }
|
|
do {
|
|
let item = try await textProvider.loadItem(forTypeIdentifier: UTType.plainText.identifier)
|
|
guard let text = item as? String else { return nil }
|
|
return text
|
|
} catch {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func loadURL(textProvider: NSItemProvider?) async -> String? {
|
|
guard let textProvider = textProvider else { return nil }
|
|
do {
|
|
let item = try await textProvider.loadItem(forTypeIdentifier: UTType.url.identifier)
|
|
guard let url = item as? URL else { return nil }
|
|
return url.absoluteString
|
|
} catch {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
extension ShareViewModel {
|
|
func publish() -> AnyPublisher<Mastodon.Response.Content<Mastodon.Entity.Status>, Error> {
|
|
guard let authentication = composeViewModel.authentication else {
|
|
return Fail(error: APIService.APIError.implicit(.authenticationMissing)).eraseToAnyPublisher()
|
|
}
|
|
let authenticationBox = MastodonAuthenticationBox(
|
|
authenticationRecord: .init(objectID: authentication.objectID),
|
|
domain: authentication.domain,
|
|
userID: authentication.userID,
|
|
appAuthorization: Mastodon.API.OAuth.Authorization(accessToken: authentication.appAccessToken),
|
|
userAuthorization: Mastodon.API.OAuth.Authorization(accessToken: authentication.userAccessToken)
|
|
)
|
|
|
|
let domain = authentication.domain
|
|
let attachmentViewModels = composeViewModel.attachmentViewModels
|
|
let mediaIDs = attachmentViewModels.compactMap { viewModel in
|
|
viewModel.attachment.value?.id
|
|
}
|
|
let sensitive: Bool = composeViewModel.isContentWarningComposing
|
|
let spoilerText: String? = {
|
|
let text = composeViewModel.contentWarningContent
|
|
guard !text.isEmpty else { return nil }
|
|
return text
|
|
}()
|
|
let visibility = selectedStatusVisibility.value.visibility
|
|
|
|
let updateMediaQuerySubscriptions: [AnyPublisher<Mastodon.Response.Content<Mastodon.Entity.Attachment>, Error>] = {
|
|
var subscriptions: [AnyPublisher<Mastodon.Response.Content<Mastodon.Entity.Attachment>, Error>] = []
|
|
for attachmentViewModel in attachmentViewModels {
|
|
guard let attachmentID = attachmentViewModel.attachment.value?.id else { continue }
|
|
let description = attachmentViewModel.descriptionContent.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !description.isEmpty else { continue }
|
|
let query = Mastodon.API.Media.UpdateMediaQuery(
|
|
file: nil,
|
|
thumbnail: nil,
|
|
description: description,
|
|
focus: nil
|
|
)
|
|
let subscription = APIService.shared.updateMedia(
|
|
domain: domain,
|
|
attachmentID: attachmentID,
|
|
query: query,
|
|
mastodonAuthenticationBox: authenticationBox
|
|
)
|
|
subscriptions.append(subscription)
|
|
}
|
|
return subscriptions
|
|
}()
|
|
|
|
let status = composeViewModel.statusContent
|
|
|
|
return Publishers.MergeMany(updateMediaQuerySubscriptions)
|
|
.collect()
|
|
.asyncMap { attachments in
|
|
let query = Mastodon.API.Statuses.PublishStatusQuery(
|
|
status: status,
|
|
mediaIDs: mediaIDs.isEmpty ? nil : mediaIDs,
|
|
pollOptions: nil,
|
|
pollExpiresIn: nil,
|
|
inReplyToID: nil,
|
|
sensitive: sensitive,
|
|
spoilerText: spoilerText,
|
|
visibility: visibility
|
|
)
|
|
return try await APIService.shared.publishStatus(
|
|
domain: domain,
|
|
idempotencyKey: nil, // FIXME:
|
|
query: query,
|
|
authenticationBox: authenticationBox
|
|
)
|
|
}
|
|
.eraseToAnyPublisher()
|
|
}
|
|
}
|