1075 lines
46 KiB
Swift
1075 lines
46 KiB
Swift
//
|
|
// Copyright 2022 New Vector Ltd
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
import Algorithms
|
|
import Combine
|
|
import OrderedCollections
|
|
import SwiftUI
|
|
|
|
typealias RoomScreenViewModelType = StateStoreViewModel<RoomScreenViewState, RoomScreenViewAction>
|
|
|
|
class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol {
|
|
private enum Constants {
|
|
static let backPaginationEventLimit: UInt = 20
|
|
static let backPaginationPageSize: UInt = 50
|
|
static let toastErrorID = "RoomScreenToastError"
|
|
}
|
|
|
|
private let timelineController: RoomTimelineControllerProtocol
|
|
private let roomProxy: RoomProxyProtocol
|
|
private let appSettings: AppSettings
|
|
private let analytics: AnalyticsService
|
|
private unowned let userIndicatorController: UserIndicatorControllerProtocol
|
|
private let notificationCenterProtocol: NotificationCenterProtocol
|
|
private let voiceMessageRecorder: VoiceMessageRecorderProtocol
|
|
private let composerFocusedSubject = PassthroughSubject<Bool, Never>()
|
|
private let mediaPlayerProvider: MediaPlayerProviderProtocol
|
|
private let actionsSubject: PassthroughSubject<RoomScreenViewModelAction, Never> = .init()
|
|
private var canCurrentUserRedact = false
|
|
private var paginateBackwardsTask: Task<Void, Never>?
|
|
|
|
init(timelineController: RoomTimelineControllerProtocol,
|
|
mediaProvider: MediaProviderProtocol,
|
|
mediaPlayerProvider: MediaPlayerProviderProtocol,
|
|
roomProxy: RoomProxyProtocol,
|
|
appSettings: AppSettings,
|
|
analytics: AnalyticsService,
|
|
userIndicatorController: UserIndicatorControllerProtocol,
|
|
notificationCenterProtocol: NotificationCenterProtocol = NotificationCenter.default) {
|
|
self.roomProxy = roomProxy
|
|
self.timelineController = timelineController
|
|
self.appSettings = appSettings
|
|
self.analytics = analytics
|
|
self.userIndicatorController = userIndicatorController
|
|
self.notificationCenterProtocol = notificationCenterProtocol
|
|
self.mediaPlayerProvider = mediaPlayerProvider
|
|
voiceMessageRecorder = VoiceMessageRecorder(audioRecorder: AudioRecorder(), mediaPlayerProvider: mediaPlayerProvider)
|
|
|
|
super.init(initialViewState: RoomScreenViewState(roomID: timelineController.roomID,
|
|
roomTitle: roomProxy.roomTitle,
|
|
roomAvatarURL: roomProxy.avatarURL,
|
|
timelineStyle: appSettings.timelineStyle,
|
|
readReceiptsEnabled: appSettings.readReceiptsEnabled,
|
|
isEncryptedOneToOneRoom: roomProxy.isEncryptedOneToOneRoom,
|
|
ownUserID: roomProxy.ownUserID,
|
|
isCallOngoing: roomProxy.isCallOngoing,
|
|
bindings: .init(reactionsCollapsed: [:])),
|
|
imageProvider: mediaProvider)
|
|
|
|
setupSubscriptions()
|
|
setupDirectRoomSubscriptionsIfNeeded()
|
|
|
|
state.timelineItemMenuActionProvider = { [weak self] itemId -> TimelineItemMenuActions? in
|
|
guard let self else {
|
|
return nil
|
|
}
|
|
|
|
return self.timelineItemMenuActionsForItemId(itemId)
|
|
}
|
|
|
|
state.audioPlayerStateProvider = { [weak self] itemId -> AudioPlayerState? in
|
|
guard let self else {
|
|
return nil
|
|
}
|
|
|
|
return self.audioPlayerState(for: itemId)
|
|
}
|
|
|
|
buildTimelineViews()
|
|
|
|
// Note: beware if we get to e.g. restore a reply / edit,
|
|
// maybe we are tracking a non-needed first initial state
|
|
trackComposerMode(.default)
|
|
}
|
|
|
|
// MARK: - Public
|
|
|
|
var actions: AnyPublisher<RoomScreenViewModelAction, Never> {
|
|
actionsSubject.eraseToAnyPublisher()
|
|
}
|
|
|
|
func stop() {
|
|
// Work around QLPreviewController dismissal issues, see the InteractiveQuickLookModifier.
|
|
state.bindings.mediaPreviewItem = nil
|
|
}
|
|
|
|
override func process(viewAction: RoomScreenViewAction) {
|
|
switch viewAction {
|
|
case .displayRoomDetails:
|
|
actionsSubject.send(.displayRoomDetails)
|
|
case .itemAppeared(let id):
|
|
Task { await timelineController.processItemAppearance(id) }
|
|
case .itemDisappeared(let id):
|
|
Task { await timelineController.processItemDisappearance(id) }
|
|
case .itemTapped(let id):
|
|
Task { await itemTapped(with: id) }
|
|
case .toggleReaction(let emoji, let itemId):
|
|
Task { await timelineController.toggleReaction(emoji, to: itemId) }
|
|
case .sendReadReceiptIfNeeded(let lastVisibleItemID):
|
|
Task { await sendReadReceiptIfNeeded(for: lastVisibleItemID) }
|
|
case .timelineItemMenu(let itemID):
|
|
Task {
|
|
if case let .success(value) = await roomProxy.canUserRedact(userID: roomProxy.ownUserID) {
|
|
canCurrentUserRedact = value
|
|
} else {
|
|
canCurrentUserRedact = false
|
|
}
|
|
showTimelineItemActionMenu(for: itemID)
|
|
}
|
|
case .timelineItemMenuAction(let itemID, let action):
|
|
processTimelineItemMenuAction(action, itemID: itemID)
|
|
case .handlePasteOrDrop(let provider):
|
|
handlePasteOrDrop(provider)
|
|
case .tappedOnUser(userID: let userID):
|
|
Task { await handleTappedUser(userID: userID) }
|
|
case .displayEmojiPicker(let itemID):
|
|
showEmojiPicker(for: itemID)
|
|
case .reactionSummary(let itemID, let key):
|
|
showReactionSummary(for: itemID, selectedKey: key)
|
|
case .retrySend(let itemID):
|
|
Task { await handleRetrySend(itemID: itemID) }
|
|
case .cancelSend(let itemID):
|
|
Task { await handleCancelSend(itemID: itemID) }
|
|
case .paginateBackwards:
|
|
paginateBackwards()
|
|
case .scrolledToBottom:
|
|
if state.swiftUITimelineEnabled {
|
|
renderPendingTimelineItems()
|
|
}
|
|
case let .selectedPollOption(pollStartID, optionID):
|
|
sendPollResponse(pollStartID: pollStartID, optionID: optionID)
|
|
case .playPauseAudio(let itemID):
|
|
Task { await timelineController.playPauseAudio(for: itemID) }
|
|
case .seekAudio(let itemID, let progress):
|
|
Task { await timelineController.seekAudio(for: itemID, progress: progress) }
|
|
case .enableLongPress(let itemID):
|
|
guard state.longPressDisabledItemID == itemID else { return }
|
|
state.longPressDisabledItemID = nil
|
|
case .disableLongPress(let itemID):
|
|
state.longPressDisabledItemID = itemID
|
|
case let .endPoll(pollStartID):
|
|
state.bindings.confirmationAlertInfo = .init(id: .init(),
|
|
title: L10n.actionEndPoll,
|
|
message: L10n.commonPollEndConfirmation,
|
|
primaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil),
|
|
secondaryButton: .init(title: L10n.actionOk, action: { self.endPoll(pollStartID: pollStartID) }))
|
|
case .presentCall:
|
|
actionsSubject.send(.displayCallScreen)
|
|
}
|
|
}
|
|
|
|
func process(composerAction: ComposerToolbarViewModelAction) {
|
|
switch composerAction {
|
|
case .sendMessage(let message, let html, let mode, let intentionalMentions):
|
|
Task {
|
|
await sendCurrentMessage(message,
|
|
html: html,
|
|
mode: mode,
|
|
intentionalMentions: intentionalMentions)
|
|
}
|
|
case .displayCameraPicker:
|
|
actionsSubject.send(.displayCameraPicker)
|
|
case .displayMediaPicker:
|
|
actionsSubject.send(.displayMediaPicker)
|
|
case .displayDocumentPicker:
|
|
actionsSubject.send(.displayDocumentPicker)
|
|
case .displayLocationPicker:
|
|
actionsSubject.send(.displayLocationPicker)
|
|
case .displayPollForm:
|
|
actionsSubject.send(.displayPollForm)
|
|
case .handlePasteOrDrop(let provider):
|
|
handlePasteOrDrop(provider)
|
|
case .composerModeChanged(mode: let mode):
|
|
trackComposerMode(mode)
|
|
case .composerFocusedChanged(isFocused: let isFocused):
|
|
composerFocusedSubject.send(isFocused)
|
|
case .startVoiceMessageRecording:
|
|
Task {
|
|
await mediaPlayerProvider.detachAllStates(except: nil)
|
|
await startRecordingVoiceMessage()
|
|
}
|
|
case .stopVoiceMessageRecording:
|
|
Task { await stopRecordingVoiceMessage() }
|
|
case .cancelVoiceMessageRecording:
|
|
Task { await cancelRecordingVoiceMessage() }
|
|
case .deleteVoiceMessageRecording:
|
|
Task { await deleteCurrentVoiceMessage() }
|
|
case .sendVoiceMessage:
|
|
Task { await sendCurrentVoiceMessage() }
|
|
case .startVoiceMessagePlayback:
|
|
Task {
|
|
await mediaPlayerProvider.detachAllStates(except: voiceMessageRecorder.previewAudioPlayerState)
|
|
await startPlayingRecordedVoiceMessage()
|
|
}
|
|
case .pauseVoiceMessagePlayback:
|
|
pausePlayingRecordedVoiceMessage()
|
|
case .seekVoiceMessagePlayback(let progress):
|
|
Task { await seekRecordedVoiceMessage(to: progress) }
|
|
}
|
|
}
|
|
|
|
// MARK: - Private
|
|
|
|
private func setupSubscriptions() {
|
|
appSettings.$swiftUITimelineEnabled
|
|
.weakAssign(to: \.state.swiftUITimelineEnabled, on: self)
|
|
.store(in: &cancellables)
|
|
|
|
timelineController.callbacks
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { [weak self] callback in
|
|
guard let self else { return }
|
|
|
|
switch callback {
|
|
case .updatedTimelineItems:
|
|
self.buildTimelineViews()
|
|
case .canBackPaginate(let canBackPaginate):
|
|
if self.state.timelineViewState.canBackPaginate != canBackPaginate {
|
|
self.state.timelineViewState.canBackPaginate = canBackPaginate
|
|
}
|
|
case .isBackPaginating(let isBackPaginating):
|
|
if self.state.timelineViewState.isBackPaginating != isBackPaginating {
|
|
self.state.timelineViewState.isBackPaginating = isBackPaginating
|
|
}
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
|
|
roomProxy
|
|
.stateUpdatesPublisher
|
|
.throttle(for: .seconds(1), scheduler: DispatchQueue.main, latest: true)
|
|
.sink { [weak self] _ in
|
|
guard let self else { return }
|
|
self.state.roomTitle = roomProxy.roomTitle
|
|
self.state.roomAvatarURL = roomProxy.avatarURL
|
|
}
|
|
.store(in: &cancellables)
|
|
|
|
appSettings.$timelineStyle
|
|
.weakAssign(to: \.state.timelineStyle, on: self)
|
|
.store(in: &cancellables)
|
|
|
|
appSettings.$readReceiptsEnabled
|
|
.weakAssign(to: \.state.readReceiptsEnabled, on: self)
|
|
.store(in: &cancellables)
|
|
|
|
appSettings.$elementCallEnabled
|
|
.weakAssign(to: \.state.showCallButton, on: self)
|
|
.store(in: &cancellables)
|
|
|
|
roomProxy.members
|
|
.map { members in
|
|
members.reduce(into: [String: RoomMemberState]()) { dictionary, member in
|
|
dictionary[member.userID] = RoomMemberState(displayName: member.displayName, avatarURL: member.avatarURL)
|
|
}
|
|
}
|
|
.receive(on: DispatchQueue.main)
|
|
.weakAssign(to: \.state.members, on: self)
|
|
.store(in: &cancellables)
|
|
}
|
|
|
|
private func setupDirectRoomSubscriptionsIfNeeded() {
|
|
guard roomProxy.isDirect else {
|
|
return
|
|
}
|
|
|
|
let shouldShowInviteAlert = composerFocusedSubject
|
|
.removeDuplicates()
|
|
.map { [weak self] isFocused in
|
|
guard let self else { return false }
|
|
|
|
return isFocused && self.roomProxy.isUserAloneInDirectRoom
|
|
}
|
|
// We want to show the alert just once, so we are taking the first "true" emitted
|
|
.first { $0 }
|
|
|
|
shouldShowInviteAlert
|
|
.sink { [weak self] _ in
|
|
self?.showInviteAlert()
|
|
}
|
|
.store(in: &cancellables)
|
|
}
|
|
|
|
private func paginateBackwards() {
|
|
guard paginateBackwardsTask == nil else {
|
|
return
|
|
}
|
|
|
|
paginateBackwardsTask = Task { [weak self] in
|
|
guard let self else {
|
|
return
|
|
}
|
|
|
|
switch await timelineController.paginateBackwards(requestSize: Constants.backPaginationEventLimit, untilNumberOfItems: Constants.backPaginationPageSize) {
|
|
case .failure:
|
|
displayError(.toast(L10n.errorFailedLoadingMessages))
|
|
default:
|
|
break
|
|
}
|
|
paginateBackwardsTask = nil
|
|
}
|
|
}
|
|
|
|
/// The ID of the newest item in the room that the user has seen.
|
|
/// This includes both event based items and virtual items.
|
|
private var lastReadItemID: TimelineItemIdentifier?
|
|
private func sendReadReceiptIfNeeded(for lastVisibleItemID: TimelineItemIdentifier) async -> Result<Void, RoomTimelineControllerError> {
|
|
guard lastReadItemID != lastVisibleItemID,
|
|
let eventItemID = eventBasedItem(nearest: lastVisibleItemID)
|
|
else { return .success(()) }
|
|
|
|
// Make sure the item is newer than the item that was last marked as read.
|
|
if let lastReadItemIndex = state.timelineViewState.timelineIDs.firstIndex(of: lastReadItemID?.timelineID ?? ""),
|
|
let lastVisibleItemIndex = state.timelineViewState.timelineIDs.firstIndex(of: eventItemID.timelineID),
|
|
lastReadItemIndex > lastVisibleItemIndex {
|
|
return .success(())
|
|
}
|
|
|
|
// Update the last read item ID to avoid attempting duplicate requests.
|
|
lastReadItemID = lastVisibleItemID
|
|
|
|
// Clear any notifications from notification center.
|
|
if lastVisibleItemID.timelineID == state.timelineViewState.timelineIDs.last {
|
|
notificationCenterProtocol.post(name: .roomMarkedAsRead, object: roomProxy.id)
|
|
}
|
|
|
|
switch await timelineController.sendReadReceipt(for: eventItemID) {
|
|
case .success:
|
|
return .success(())
|
|
case .failure:
|
|
return .failure(.generic)
|
|
}
|
|
}
|
|
|
|
/// Returns the first item ID that contains an `eventID` starting from the supplied ID, working backwards through the timeline.
|
|
private func eventBasedItem(nearest itemID: TimelineItemIdentifier) -> TimelineItemIdentifier? {
|
|
guard itemID.eventID == nil else { return itemID }
|
|
|
|
let timelineIDs = state.timelineViewState.itemViewStates.map(\.identifier)
|
|
guard let index = timelineIDs.firstIndex(of: itemID) else { return nil }
|
|
|
|
let nearestItemID = timelineIDs[..<index].last(where: { $0.eventID != nil })
|
|
return nearestItemID
|
|
}
|
|
|
|
private func itemTapped(with itemID: TimelineItemIdentifier) async {
|
|
state.showLoading = true
|
|
let action = await timelineController.processItemTap(itemID)
|
|
|
|
switch action {
|
|
case .displayMediaFile(let file, let title):
|
|
actionsSubject.send(.composer(action: .removeFocus)) // Hide the keyboard otherwise a big white space is sometimes shown when dismissing the preview.
|
|
state.bindings.mediaPreviewItem = MediaPreviewItem(file: file, title: title)
|
|
case .displayLocation(let body, let geoURI, let description):
|
|
actionsSubject.send(.displayLocation(body: body, geoURI: geoURI, description: description))
|
|
case .none:
|
|
break
|
|
}
|
|
state.showLoading = false
|
|
}
|
|
|
|
private func buildTimelineViews() {
|
|
var timelineItemsDictionary = OrderedDictionary<String, RoomTimelineItemViewState>()
|
|
|
|
let itemsGroupedByTimelineDisplayStyle = timelineController.timelineItems.chunked { current, next in
|
|
canGroupItem(timelineItem: current, with: next)
|
|
}
|
|
|
|
for itemGroup in itemsGroupedByTimelineDisplayStyle {
|
|
guard !itemGroup.isEmpty else {
|
|
MXLog.error("Found empty item group")
|
|
continue
|
|
}
|
|
|
|
if itemGroup.count == 1 {
|
|
if let firstItem = itemGroup.first {
|
|
timelineItemsDictionary.updateValue(updateViewState(item: firstItem, groupStyle: .single),
|
|
forKey: firstItem.id.timelineID)
|
|
}
|
|
} else {
|
|
for (index, item) in itemGroup.enumerated() {
|
|
if index == 0 {
|
|
timelineItemsDictionary.updateValue(updateViewState(item: item, groupStyle: .first),
|
|
forKey: item.id.timelineID)
|
|
} else if index == itemGroup.count - 1 {
|
|
timelineItemsDictionary.updateValue(updateViewState(item: item, groupStyle: .last),
|
|
forKey: item.id.timelineID)
|
|
} else {
|
|
timelineItemsDictionary.updateValue(updateViewState(item: item, groupStyle: .middle),
|
|
forKey: item.id.timelineID)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// The SwiftUI scroll view needs special handling, see `selectivelyUpdateTimelineItems`
|
|
if state.swiftUITimelineEnabled {
|
|
selectivelyUpdateTimelineItems(timelineItemsDictionary: timelineItemsDictionary)
|
|
} else {
|
|
state.timelineViewState.itemsDictionary = timelineItemsDictionary
|
|
state.timelineViewState.renderedTimelineIDs = Array(timelineItemsDictionary.keys)
|
|
}
|
|
}
|
|
|
|
private func updateViewState(item: RoomTimelineItemProtocol, groupStyle: TimelineGroupStyle) -> RoomTimelineItemViewState {
|
|
if let timelineItemViewState = state.timelineViewState.itemsDictionary[item.id.timelineID] {
|
|
timelineItemViewState.groupStyle = groupStyle
|
|
timelineItemViewState.type = .init(item: item)
|
|
return timelineItemViewState
|
|
} else {
|
|
return RoomTimelineItemViewState(item: item, groupStyle: groupStyle)
|
|
}
|
|
}
|
|
|
|
/// With the timeline scroll being reversed, introducing items at it's top (i.e. bottom now) will make the content move upwards, which is unwanted when
|
|
/// reading history. Delay rendering new items until it reaches the bottom again.
|
|
private func selectivelyUpdateTimelineItems(timelineItemsDictionary: OrderedDictionary<String, RoomTimelineItemViewState>) {
|
|
var timelineViewState = state.timelineViewState
|
|
|
|
let newItemIdentifiers = Array(timelineItemsDictionary.keys)
|
|
|
|
if !state.bindings.isScrolledToBottom,
|
|
let lastItemIdentifier = state.timelineViewState.renderedTimelineIDs.last,
|
|
let newLastItemIdentifierIndex = newItemIdentifiers.firstIndex(where: { $0 == lastItemIdentifier }) {
|
|
timelineViewState.pendingTimelineIDs = Array(newItemIdentifiers.dropFirst(newLastItemIdentifierIndex + 1))
|
|
timelineViewState.renderedTimelineIDs = Array(newItemIdentifiers.dropLast(newItemIdentifiers.count - (newLastItemIdentifierIndex + 1)))
|
|
} else {
|
|
// Otherwise just render everything normally
|
|
timelineViewState.renderedTimelineIDs = Array(timelineItemsDictionary.keys)
|
|
}
|
|
|
|
timelineViewState.itemsDictionary = timelineItemsDictionary
|
|
|
|
state.timelineViewState = timelineViewState
|
|
}
|
|
|
|
private func renderPendingTimelineItems() {
|
|
// Render pending timeline items when the scroll view reaches the bottom again
|
|
guard state.bindings.isScrolledToBottom,
|
|
state.timelineViewState.pendingTimelineIDs.count > 0 else {
|
|
return
|
|
}
|
|
|
|
var newTimelineViewState = state.timelineViewState
|
|
newTimelineViewState.renderedTimelineIDs = state.timelineViewState.renderedTimelineIDs + state.timelineViewState.pendingTimelineIDs
|
|
newTimelineViewState.pendingTimelineIDs = []
|
|
state.timelineViewState = newTimelineViewState
|
|
}
|
|
|
|
private func canGroupItem(timelineItem: RoomTimelineItemProtocol, with otherTimelineItem: RoomTimelineItemProtocol) -> Bool {
|
|
if timelineItem is CollapsibleTimelineItem || otherTimelineItem is CollapsibleTimelineItem {
|
|
return false
|
|
}
|
|
|
|
guard let eventTimelineItem = timelineItem as? EventBasedTimelineItemProtocol,
|
|
let otherEventTimelineItem = otherTimelineItem as? EventBasedTimelineItemProtocol else {
|
|
return false
|
|
}
|
|
|
|
// State events aren't rendered as messages so shouldn't be grouped.
|
|
if eventTimelineItem is StateRoomTimelineItem || otherEventTimelineItem is StateRoomTimelineItem {
|
|
return false
|
|
}
|
|
|
|
// can be improved by adding a date threshold
|
|
return eventTimelineItem.properties.reactions.isEmpty && eventTimelineItem.sender == otherEventTimelineItem.sender
|
|
}
|
|
|
|
private func sendCurrentMessage(_ message: String, html: String?, mode: RoomScreenComposerMode, intentionalMentions: IntentionalMentions) async {
|
|
guard !message.isEmpty else {
|
|
fatalError("This message should never be empty")
|
|
}
|
|
|
|
actionsSubject.send(.composer(action: .clear))
|
|
|
|
switch mode {
|
|
case .reply(let itemId, _, _):
|
|
await timelineController.sendMessage(message,
|
|
html: html,
|
|
inReplyTo: itemId,
|
|
intentionalMentions: intentionalMentions)
|
|
case .edit(let originalItemId):
|
|
await timelineController.editMessage(message,
|
|
html: html,
|
|
original: originalItemId,
|
|
intentionalMentions: intentionalMentions)
|
|
case .default:
|
|
await timelineController.sendMessage(message,
|
|
html: html,
|
|
intentionalMentions: intentionalMentions)
|
|
case .recordVoiceMessage, .previewVoiceMessage:
|
|
fatalError("invalid composer mode.")
|
|
}
|
|
}
|
|
|
|
private func trackComposerMode(_ mode: RoomScreenComposerMode) {
|
|
var isEdit = false
|
|
var isReply = false
|
|
switch mode {
|
|
case .edit:
|
|
isEdit = true
|
|
case .reply:
|
|
isReply = true
|
|
default:
|
|
break
|
|
}
|
|
|
|
analytics.trackComposer(inThread: false, isEditing: isEdit, isReply: isReply, startsThread: nil)
|
|
}
|
|
|
|
private func displayError(_ type: RoomScreenErrorType) {
|
|
switch type {
|
|
case .alert(let message):
|
|
state.bindings.alertInfo = AlertInfo(id: type,
|
|
title: L10n.commonError,
|
|
message: message)
|
|
case .toast(let message):
|
|
userIndicatorController.submitIndicator(UserIndicator(id: Constants.toastErrorID,
|
|
type: .toast,
|
|
title: message,
|
|
iconName: "xmark"))
|
|
}
|
|
}
|
|
|
|
// MARK: TimelineItemActionMenu
|
|
|
|
private func showTimelineItemActionMenu(for itemID: TimelineItemIdentifier) {
|
|
guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID),
|
|
let eventTimelineItem = timelineItem as? EventBasedTimelineItemProtocol else {
|
|
// Don't show a menu for non-event based items.
|
|
return
|
|
}
|
|
|
|
actionsSubject.send(.composer(action: .removeFocus))
|
|
state.bindings.actionMenuInfo = .init(item: eventTimelineItem)
|
|
}
|
|
|
|
// swiftlint:disable:next cyclomatic_complexity
|
|
private func timelineItemMenuActionsForItemId(_ itemID: TimelineItemIdentifier) -> TimelineItemMenuActions? {
|
|
guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID),
|
|
let item = timelineItem as? EventBasedTimelineItemProtocol else {
|
|
// Don't show a context menu for non-event based items.
|
|
return nil
|
|
}
|
|
|
|
if timelineItem is StateRoomTimelineItem {
|
|
// Don't show a context menu for state events.
|
|
return nil
|
|
}
|
|
|
|
var debugActions: [TimelineItemMenuAction] = []
|
|
if appSettings.canShowDeveloperOptions || appSettings.viewSourceEnabled {
|
|
debugActions.append(.viewSource)
|
|
}
|
|
|
|
if let encryptedItem = timelineItem as? EncryptedRoomTimelineItem {
|
|
switch encryptedItem.encryptionType {
|
|
case .megolmV1AesSha2(let sessionID):
|
|
debugActions.append(.retryDecryption(sessionID: sessionID))
|
|
default:
|
|
break
|
|
}
|
|
|
|
return .init(actions: [.copyPermalink], debugActions: debugActions)
|
|
}
|
|
|
|
var actions: [TimelineItemMenuAction] = []
|
|
|
|
if item.canBeRepliedTo {
|
|
if let messageItem = item as? EventBasedMessageTimelineItemProtocol {
|
|
actions.append(.reply(isThread: messageItem.isThreaded))
|
|
} else {
|
|
actions.append(.reply(isThread: false))
|
|
}
|
|
}
|
|
|
|
if item.isRemoteMessage {
|
|
actions.append(.forward(itemID: itemID))
|
|
}
|
|
|
|
if item.isEditable {
|
|
actions.append(.edit)
|
|
}
|
|
|
|
if item.isCopyable {
|
|
actions.append(.copy)
|
|
}
|
|
|
|
actions.append(.copyPermalink)
|
|
|
|
if canRedactItem(item), let poll = item.pollIfAvailable, !poll.hasEnded, let eventID = itemID.eventID {
|
|
actions.append(.endPoll(pollStartID: eventID))
|
|
}
|
|
|
|
if canRedactItem(item) {
|
|
actions.append(.redact)
|
|
}
|
|
|
|
if !item.isOutgoing {
|
|
actions.append(.report)
|
|
}
|
|
|
|
if item.hasFailedToSend {
|
|
actions = actions.filter(\.canAppearInFailedEcho)
|
|
}
|
|
|
|
if item.isRedacted {
|
|
actions = actions.filter(\.canAppearInRedacted)
|
|
}
|
|
|
|
return .init(actions: actions, debugActions: debugActions)
|
|
}
|
|
|
|
private func canRedactItem(_ item: EventBasedTimelineItemProtocol) -> Bool {
|
|
item.isOutgoing || (canCurrentUserRedact && !roomProxy.isDirect)
|
|
}
|
|
|
|
private func processTimelineItemMenuAction(_ action: TimelineItemMenuAction, itemID: TimelineItemIdentifier) {
|
|
guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID),
|
|
let eventTimelineItem = timelineItem as? EventBasedTimelineItemProtocol else {
|
|
return
|
|
}
|
|
|
|
switch action {
|
|
case .copy:
|
|
guard let messageTimelineItem = timelineItem as? EventBasedMessageTimelineItemProtocol else {
|
|
return
|
|
}
|
|
|
|
UIPasteboard.general.string = messageTimelineItem.body
|
|
case .edit:
|
|
guard let messageTimelineItem = timelineItem as? EventBasedMessageTimelineItemProtocol else {
|
|
return
|
|
}
|
|
|
|
let text: String
|
|
switch messageTimelineItem.contentType {
|
|
case .text(let textItem):
|
|
if ServiceLocator.shared.settings.richTextEditorEnabled, let formattedBodyHTMLString = textItem.formattedBodyHTMLString {
|
|
text = formattedBodyHTMLString
|
|
} else {
|
|
text = messageTimelineItem.body
|
|
}
|
|
case .emote(let emoteItem):
|
|
if ServiceLocator.shared.settings.richTextEditorEnabled, let formattedBodyHTMLString = emoteItem.formattedBodyHTMLString {
|
|
text = "/me " + formattedBodyHTMLString
|
|
} else {
|
|
text = "/me " + messageTimelineItem.body
|
|
}
|
|
default:
|
|
text = messageTimelineItem.body
|
|
}
|
|
|
|
actionsSubject.send(.composer(action: .setText(text: text)))
|
|
actionsSubject.send(.composer(action: .setMode(mode: .edit(originalItemId: messageTimelineItem.id))))
|
|
case .copyPermalink:
|
|
do {
|
|
guard let eventID = eventTimelineItem.id.eventID else {
|
|
displayError(.alert(L10n.errorFailedCreatingThePermalink))
|
|
break
|
|
}
|
|
|
|
let permalink = try PermalinkBuilder.permalinkTo(eventIdentifier: eventID, roomIdentifier: timelineController.roomID,
|
|
baseURL: appSettings.permalinkBaseURL)
|
|
UIPasteboard.general.url = permalink
|
|
} catch {
|
|
displayError(.alert(L10n.errorFailedCreatingThePermalink))
|
|
}
|
|
case .redact:
|
|
Task {
|
|
if eventTimelineItem.hasFailedToSend {
|
|
await timelineController.cancelSend(itemID)
|
|
} else {
|
|
await timelineController.redact(itemID)
|
|
}
|
|
}
|
|
case .reply:
|
|
let replyInfo = buildReplyInfo(for: eventTimelineItem)
|
|
let replyDetails = TimelineItemReplyDetails.loaded(sender: eventTimelineItem.sender, contentType: replyInfo.type)
|
|
|
|
actionsSubject.send(.composer(action: .setMode(mode: .reply(itemID: eventTimelineItem.id, replyDetails: replyDetails, isThread: replyInfo.isThread))))
|
|
case .forward(let itemID):
|
|
actionsSubject.send(.displayMessageForwarding(itemID: itemID))
|
|
case .viewSource:
|
|
let debugInfo = timelineController.debugInfo(for: eventTimelineItem.id)
|
|
MXLog.info(debugInfo)
|
|
state.bindings.debugInfo = debugInfo
|
|
case .retryDecryption(let sessionID):
|
|
Task {
|
|
await timelineController.retryDecryption(for: sessionID)
|
|
}
|
|
case .report:
|
|
actionsSubject.send(.displayReportContent(itemID: itemID, senderID: eventTimelineItem.sender.id))
|
|
case .react:
|
|
showEmojiPicker(for: itemID)
|
|
case .endPoll(let pollStartID):
|
|
endPoll(pollStartID: pollStartID)
|
|
}
|
|
|
|
if action.switchToDefaultComposer {
|
|
actionsSubject.send(.composer(action: .setMode(mode: .default)))
|
|
}
|
|
}
|
|
|
|
// Pasting and dropping
|
|
|
|
private func handlePasteOrDrop(_ provider: NSItemProvider) {
|
|
guard let contentType = provider.preferredContentType,
|
|
let preferredExtension = contentType.preferredFilenameExtension else {
|
|
MXLog.error("Invalid NSItemProvider: \(provider)")
|
|
displayError(.toast(L10n.screenRoomErrorFailedProcessingMedia))
|
|
return
|
|
}
|
|
|
|
let providerSuggestedName = provider.suggestedName
|
|
let providerDescription = provider.description
|
|
|
|
_ = provider.loadDataRepresentation(for: contentType) { data, error in
|
|
Task { @MainActor in
|
|
let loadingIndicatorIdentifier = UUID().uuidString
|
|
self.userIndicatorController.submitIndicator(UserIndicator(id: loadingIndicatorIdentifier, type: .modal, title: L10n.commonLoading, persistent: true))
|
|
defer {
|
|
self.userIndicatorController.retractIndicatorWithId(loadingIndicatorIdentifier)
|
|
}
|
|
|
|
if let error {
|
|
self.displayError(.toast(L10n.screenRoomErrorFailedProcessingMedia))
|
|
MXLog.error("Failed processing NSItemProvider: \(providerDescription) with error: \(error)")
|
|
return
|
|
}
|
|
|
|
guard let data else {
|
|
self.displayError(.toast(L10n.screenRoomErrorFailedProcessingMedia))
|
|
MXLog.error("Invalid NSItemProvider data: \(providerDescription)")
|
|
return
|
|
}
|
|
|
|
do {
|
|
let url = try await Task.detached {
|
|
if let filename = providerSuggestedName {
|
|
let hasExtension = !(filename as NSString).pathExtension.isEmpty
|
|
let filename = hasExtension ? filename : "\(filename).\(preferredExtension)"
|
|
return try FileManager.default.writeDataToTemporaryDirectory(data: data, fileName: filename)
|
|
} else {
|
|
let filename = "\(UUID().uuidString).\(preferredExtension)"
|
|
return try FileManager.default.writeDataToTemporaryDirectory(data: data, fileName: filename)
|
|
}
|
|
}.value
|
|
|
|
self.actionsSubject.send(.displayMediaUploadPreviewScreen(url: url))
|
|
} catch {
|
|
self.displayError(.toast(L10n.screenRoomErrorFailedProcessingMedia))
|
|
MXLog.error("Failed storing NSItemProvider data \(providerDescription) with error: \(error)")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func buildReplyInfo(for item: EventBasedTimelineItemProtocol) -> ReplyInfo {
|
|
guard let messageItem = item as? EventBasedMessageTimelineItemProtocol else {
|
|
return .init(type: .text(.init(body: item.body)), isThread: false)
|
|
}
|
|
|
|
return .init(type: messageItem.contentType, isThread: messageItem.isThreaded)
|
|
}
|
|
|
|
private func handleTappedUser(userID: String) async {
|
|
// This is generally fast but it could take some time for rooms with thousands of users on first load
|
|
// Show a loader only if it takes more than 0.1 seconds
|
|
showLoadingIndicator(with: .milliseconds(100))
|
|
let result = await roomProxy.getMember(userID: userID)
|
|
hideLoadingIndicator()
|
|
|
|
switch result {
|
|
case .success(let member):
|
|
actionsSubject.send(.displayRoomMemberDetails(member: member))
|
|
case .failure(let error):
|
|
displayError(.alert(L10n.screenRoomErrorFailedRetrievingUserDetails))
|
|
MXLog.error("Failed retrieving the user given the following id \(userID) with error: \(error)")
|
|
}
|
|
}
|
|
|
|
private func handleRetrySend(itemID: TimelineItemIdentifier) async {
|
|
guard let transactionID = itemID.transactionID else {
|
|
MXLog.error("Failed Retry Send: missing transaction ID")
|
|
return
|
|
}
|
|
|
|
await roomProxy.retrySend(transactionID: transactionID)
|
|
}
|
|
|
|
private func handleCancelSend(itemID: TimelineItemIdentifier) async {
|
|
guard let transactionID = itemID.transactionID else {
|
|
MXLog.error("Failed Cancel Send: missing transaction ID")
|
|
return
|
|
}
|
|
|
|
await roomProxy.cancelSend(transactionID: transactionID)
|
|
}
|
|
|
|
private static let loadingIndicatorIdentifier = "RoomScreenLoadingIndicator"
|
|
|
|
private func showLoadingIndicator(with delay: Duration) {
|
|
userIndicatorController.submitIndicator(UserIndicator(id: Self.loadingIndicatorIdentifier,
|
|
type: .modal(progress: .indeterminate, interactiveDismissDisabled: true, allowsInteraction: false),
|
|
title: L10n.commonLoading,
|
|
persistent: true),
|
|
delay: delay)
|
|
}
|
|
|
|
private func hideLoadingIndicator() {
|
|
userIndicatorController.retractIndicatorWithId(Self.loadingIndicatorIdentifier)
|
|
}
|
|
|
|
// MARK: - Direct chats logics
|
|
|
|
private func showInviteAlert() {
|
|
userIndicatorController.alertInfo = .init(id: .init(),
|
|
title: L10n.screenRoomInviteAgainAlertTitle,
|
|
message: L10n.screenRoomInviteAgainAlertMessage,
|
|
primaryButton: .init(title: L10n.actionInvite, action: { [weak self] in self?.inviteOtherDMUserBack() }),
|
|
secondaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil))
|
|
}
|
|
|
|
private let inviteLoadingIndicatorID = UUID().uuidString
|
|
|
|
private func inviteOtherDMUserBack() {
|
|
guard roomProxy.isUserAloneInDirectRoom else {
|
|
userIndicatorController.alertInfo = .init(id: .init(), title: L10n.commonError)
|
|
return
|
|
}
|
|
|
|
Task {
|
|
userIndicatorController.submitIndicator(.init(id: inviteLoadingIndicatorID, type: .toast, title: L10n.commonLoading))
|
|
defer {
|
|
userIndicatorController.retractIndicatorWithId(inviteLoadingIndicatorID)
|
|
}
|
|
|
|
guard
|
|
let members = await roomProxy.members(),
|
|
members.count == 2,
|
|
let otherPerson = members.first(where: { !$0.isAccountOwner && $0.membership == .leave })
|
|
else {
|
|
userIndicatorController.alertInfo = .init(id: .init(), title: L10n.commonError)
|
|
return
|
|
}
|
|
|
|
switch await roomProxy.invite(userID: otherPerson.userID) {
|
|
case .success:
|
|
break
|
|
case .failure:
|
|
userIndicatorController.alertInfo = .init(id: .init(),
|
|
title: L10n.commonUnableToInviteTitle,
|
|
message: L10n.commonUnableToInviteMessage)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Reactions
|
|
|
|
private func showEmojiPicker(for itemID: TimelineItemIdentifier) {
|
|
guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID),
|
|
timelineItem.isReactable,
|
|
let eventTimelineItem = timelineItem as? EventBasedTimelineItemProtocol else {
|
|
return
|
|
}
|
|
let selectedEmojis = Set(eventTimelineItem.properties.reactions.compactMap { $0.isHighlighted ? $0.key : nil })
|
|
actionsSubject.send(.displayEmojiPicker(itemID: itemID, selectedEmojis: selectedEmojis))
|
|
}
|
|
|
|
private func showReactionSummary(for itemID: TimelineItemIdentifier, selectedKey: String) {
|
|
guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID),
|
|
let eventTimelineItem = timelineItem as? EventBasedTimelineItemProtocol else {
|
|
return
|
|
}
|
|
|
|
state.bindings.reactionSummaryInfo = .init(reactions: eventTimelineItem.properties.reactions, selectedKey: selectedKey)
|
|
}
|
|
|
|
// MARK: - Polls
|
|
|
|
private func sendPollResponse(pollStartID: String, optionID: String) {
|
|
Task {
|
|
let sendPollResponseResult = await roomProxy.sendPollResponse(pollStartID: pollStartID, answers: [optionID])
|
|
analytics.trackPollVote()
|
|
|
|
switch sendPollResponseResult {
|
|
case .success:
|
|
break
|
|
case .failure:
|
|
displayError(.toast(L10n.errorUnknown))
|
|
}
|
|
}
|
|
}
|
|
|
|
private func endPoll(pollStartID: String) {
|
|
Task {
|
|
let endPollResult = await roomProxy.endPoll(pollStartID: pollStartID,
|
|
text: "The poll with event id: \(pollStartID) has ended")
|
|
analytics.trackPollEnd()
|
|
switch endPollResult {
|
|
case .success:
|
|
break
|
|
case .failure:
|
|
displayError(.toast(L10n.errorUnknown))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Audio
|
|
|
|
private func audioPlayerState(for itemID: TimelineItemIdentifier) -> AudioPlayerState {
|
|
timelineController.audioPlayerState(for: itemID)
|
|
}
|
|
|
|
// MARK: - Voice message
|
|
|
|
private func stopVoiceMessageRecorder() async {
|
|
_ = await voiceMessageRecorder.stopRecording()
|
|
await voiceMessageRecorder.stopPlayback()
|
|
}
|
|
|
|
private func startRecordingVoiceMessage() async {
|
|
let audioRecordState = AudioRecorderState()
|
|
audioRecordState.attachAudioRecorder(voiceMessageRecorder.audioRecorder)
|
|
|
|
switch await voiceMessageRecorder.startRecording() {
|
|
case .success:
|
|
actionsSubject.send(.composer(action: .setMode(mode: .recordVoiceMessage(state: audioRecordState))))
|
|
case .failure(let error):
|
|
switch error {
|
|
case .audioRecorderError(.recordPermissionNotGranted):
|
|
state.bindings.confirmationAlertInfo = .init(id: .init(),
|
|
title: "",
|
|
message: L10n.dialogPermissionMicrophone,
|
|
primaryButton: .init(title: L10n.actionOpenSettings, action: { [weak self] in self?.openSystemSettings() }),
|
|
secondaryButton: .init(title: L10n.actionNotNow, role: .cancel, action: nil))
|
|
default:
|
|
MXLog.error("failed to start voice message recording: \(error)")
|
|
}
|
|
}
|
|
}
|
|
|
|
private func stopRecordingVoiceMessage() async {
|
|
if case .failure(let error) = await voiceMessageRecorder.stopRecording() {
|
|
MXLog.error("failed to stop the recording", context: error)
|
|
return
|
|
}
|
|
|
|
guard let audioPlayerState = voiceMessageRecorder.previewAudioPlayerState else {
|
|
MXLog.error("the recorder preview is missing after the recording has been stopped")
|
|
return
|
|
}
|
|
|
|
guard let recordingURL = voiceMessageRecorder.recordingURL else {
|
|
MXLog.error("the recording URL is missing after the recording has been stopped")
|
|
return
|
|
}
|
|
|
|
mediaPlayerProvider.register(audioPlayerState: audioPlayerState)
|
|
actionsSubject.send(.composer(action: .setMode(mode: .previewVoiceMessage(state: audioPlayerState, waveform: .url(recordingURL)))))
|
|
}
|
|
|
|
private func cancelRecordingVoiceMessage() async {
|
|
await voiceMessageRecorder.cancelRecording()
|
|
actionsSubject.send(.composer(action: .setMode(mode: .default)))
|
|
}
|
|
|
|
private func deleteCurrentVoiceMessage() async {
|
|
await voiceMessageRecorder.deleteRecording()
|
|
actionsSubject.send(.composer(action: .setMode(mode: .default)))
|
|
}
|
|
|
|
private func sendCurrentVoiceMessage() async {
|
|
await voiceMessageRecorder.stopPlayback()
|
|
switch await voiceMessageRecorder.sendVoiceMessage(inRoom: roomProxy, audioConverter: AudioConverter()) {
|
|
case .success:
|
|
await deleteCurrentVoiceMessage()
|
|
case .failure(let error):
|
|
MXLog.error("failed to send the voice message", context: error)
|
|
}
|
|
}
|
|
|
|
private func startPlayingRecordedVoiceMessage() async {
|
|
if case .failure(let error) = await voiceMessageRecorder.startPlayback() {
|
|
MXLog.error("failed to play recorded voice message", context: error)
|
|
}
|
|
}
|
|
|
|
private func pausePlayingRecordedVoiceMessage() {
|
|
voiceMessageRecorder.pausePlayback()
|
|
}
|
|
|
|
private func seekRecordedVoiceMessage(to progress: Double) async {
|
|
await voiceMessageRecorder.seekPlayback(to: progress)
|
|
}
|
|
|
|
private func openSystemSettings() {
|
|
guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
|
|
UIApplication.shared.open(url)
|
|
}
|
|
}
|
|
|
|
private extension RoomProxyProtocol {
|
|
/// Checks if the other person left the room in a direct chat
|
|
var isUserAloneInDirectRoom: Bool {
|
|
isDirect && activeMembersCount == 1
|
|
}
|
|
}
|
|
|
|
extension RoomScreenViewModel.Context {
|
|
/// A function to make it easier to bind to reactions expand/collapsed state
|
|
/// - Parameter itemID: The id of the timeline item the reacted to
|
|
/// - Returns: Wether the reactions should show in the collapsed state, true by default.
|
|
func reactionsCollapsedBinding(for itemID: TimelineItemIdentifier) -> Binding<Bool> {
|
|
Binding(get: {
|
|
self.reactionsCollapsed[itemID] ?? true
|
|
}, set: {
|
|
self.reactionsCollapsed[itemID] = $0
|
|
})
|
|
}
|
|
}
|
|
|
|
// MARK: - Mocks
|
|
|
|
extension RoomScreenViewModel {
|
|
static let mock = RoomScreenViewModel(timelineController: MockRoomTimelineController(),
|
|
mediaProvider: MockMediaProvider(),
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
roomProxy: RoomProxyMock(with: .init(displayName: "Preview room")),
|
|
appSettings: ServiceLocator.shared.settings,
|
|
analytics: ServiceLocator.shared.analytics,
|
|
userIndicatorController: ServiceLocator.shared.userIndicatorController)
|
|
}
|
|
|
|
private struct ReplyInfo {
|
|
let type: EventBasedMessageTimelineItemContentType
|
|
let isThread: Bool
|
|
}
|
|
|
|
private struct RoomContextKey: EnvironmentKey {
|
|
@MainActor
|
|
static let defaultValue = RoomScreenViewModel.mock.context
|
|
}
|
|
|
|
extension EnvironmentValues {
|
|
/// Used to access and inject and access the room context without observing it
|
|
var roomContext: RoomScreenViewModel.Context {
|
|
get { self[RoomContextKey.self] }
|
|
set { self[RoomContextKey.self] = newValue }
|
|
}
|
|
}
|