forked from GitHub-Mirror/riotX-android
291 lines
12 KiB
Kotlin
291 lines
12 KiB
Kotlin
/*
|
|
* Copyright 2019 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.
|
|
*/
|
|
package im.vector.riotx.features.home.room.detail.timeline.action
|
|
|
|
import com.airbnb.mvrx.*
|
|
import com.squareup.inject.assisted.Assisted
|
|
import com.squareup.inject.assisted.AssistedInject
|
|
import im.vector.matrix.android.api.session.Session
|
|
import im.vector.matrix.android.api.session.events.model.EventType
|
|
import im.vector.matrix.android.api.session.events.model.isTextMessage
|
|
import im.vector.matrix.android.api.session.events.model.toModel
|
|
import im.vector.matrix.android.api.session.room.model.message.MessageContent
|
|
import im.vector.matrix.android.api.session.room.model.message.MessageImageContent
|
|
import im.vector.matrix.android.api.session.room.model.message.MessageType
|
|
import im.vector.matrix.android.api.session.room.send.SendState
|
|
import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
|
|
import im.vector.matrix.rx.RxRoom
|
|
import im.vector.riotx.R
|
|
import im.vector.riotx.core.extensions.canReact
|
|
import im.vector.riotx.core.platform.VectorViewModel
|
|
import im.vector.riotx.core.resources.StringProvider
|
|
import im.vector.riotx.core.utils.isSingleEmoji
|
|
import im.vector.riotx.features.home.room.detail.timeline.item.MessageInformationData
|
|
|
|
|
|
data class SimpleAction(val uid: String, val titleRes: Int, val iconResId: Int?, val data: Any? = null)
|
|
|
|
data class MessageMenuState(
|
|
val roomId: String,
|
|
val eventId: String,
|
|
val informationData: MessageInformationData,
|
|
val actions: Async<List<SimpleAction>> = Uninitialized
|
|
) : MvRxState {
|
|
|
|
constructor(args: TimelineEventFragmentArgs) : this(roomId = args.roomId, eventId = args.eventId, informationData = args.informationData)
|
|
|
|
}
|
|
|
|
/**
|
|
* Manages list actions for a given message (copy / paste / forward...)
|
|
*/
|
|
class MessageMenuViewModel @AssistedInject constructor(@Assisted initialState: MessageMenuState,
|
|
private val session: Session,
|
|
private val stringProvider: StringProvider) : VectorViewModel<MessageMenuState>(initialState) {
|
|
|
|
@AssistedInject.Factory
|
|
interface Factory {
|
|
fun create(initialState: MessageMenuState): MessageMenuViewModel
|
|
}
|
|
|
|
private val room = session.getRoom(initialState.roomId)
|
|
?: throw IllegalStateException("Shouldn't use this ViewModel without a room")
|
|
|
|
private val eventId = initialState.eventId
|
|
private val informationData: MessageInformationData = initialState.informationData
|
|
|
|
companion object : MvRxViewModelFactory<MessageMenuViewModel, MessageMenuState> {
|
|
|
|
const val ACTION_ADD_REACTION = "add_reaction"
|
|
const val ACTION_COPY = "copy"
|
|
const val ACTION_EDIT = "edit"
|
|
const val ACTION_QUOTE = "quote"
|
|
const val ACTION_REPLY = "reply"
|
|
const val ACTION_SHARE = "share"
|
|
const val ACTION_RESEND = "resend"
|
|
const val ACTION_REMOVE = "remove"
|
|
const val ACTION_DELETE = "delete"
|
|
const val ACTION_CANCEL = "cancel"
|
|
const val VIEW_SOURCE = "VIEW_SOURCE"
|
|
const val VIEW_DECRYPTED_SOURCE = "VIEW_DECRYPTED_SOURCE"
|
|
const val ACTION_COPY_PERMALINK = "ACTION_COPY_PERMALINK"
|
|
const val ACTION_FLAG = "ACTION_FLAG"
|
|
const val ACTION_QUICK_REACT = "ACTION_QUICK_REACT"
|
|
const val ACTION_VIEW_REACTIONS = "ACTION_VIEW_REACTIONS"
|
|
|
|
override fun create(viewModelContext: ViewModelContext, state: MessageMenuState): MessageMenuViewModel? {
|
|
val fragment: MessageMenuFragment = (viewModelContext as FragmentViewModelContext).fragment()
|
|
return fragment.messageMenuViewModelFactory.create(state)
|
|
}
|
|
}
|
|
|
|
init {
|
|
observeEvent()
|
|
}
|
|
|
|
private fun observeEvent() {
|
|
RxRoom(room)
|
|
.liveTimelineEvent(eventId)
|
|
?.map {
|
|
actionsForEvent(it)
|
|
}
|
|
?.execute {
|
|
copy(actions = it)
|
|
}
|
|
}
|
|
|
|
private fun actionsForEvent(event: TimelineEvent): List<SimpleAction> {
|
|
|
|
val messageContent: MessageContent? = event.annotations?.editSummary?.aggregatedContent.toModel()
|
|
?: event.root.getClearContent().toModel()
|
|
val type = messageContent?.type
|
|
|
|
return if (event.root.sendState.hasFailed()) {
|
|
arrayListOf<SimpleAction>().apply {
|
|
if (canRetry(event)) {
|
|
this.add(SimpleAction(ACTION_RESEND, R.string.global_retry, R.drawable.ic_refresh_cw, eventId))
|
|
}
|
|
this.add(SimpleAction(ACTION_REMOVE, R.string.remove, R.drawable.ic_trash, eventId))
|
|
}
|
|
} else if (event.root.sendState.isSending()) {
|
|
//TODO is uploading attachment?
|
|
arrayListOf<SimpleAction>().apply {
|
|
if (canCancel(event)) {
|
|
this.add(SimpleAction(ACTION_CANCEL, R.string.cancel, R.drawable.ic_close_round, eventId))
|
|
}
|
|
}
|
|
} else {
|
|
arrayListOf<SimpleAction>().apply {
|
|
|
|
if (!event.root.isRedacted()) {
|
|
|
|
if (canReply(event, messageContent)) {
|
|
add(SimpleAction(ACTION_REPLY, R.string.reply, R.drawable.ic_reply, eventId))
|
|
}
|
|
|
|
if (canEdit(event, session.myUserId)) {
|
|
add(SimpleAction(ACTION_EDIT, R.string.edit, R.drawable.ic_edit, eventId))
|
|
}
|
|
|
|
if (canRedact(event, session.myUserId)) {
|
|
add(SimpleAction(ACTION_DELETE, R.string.delete, R.drawable.ic_delete, eventId))
|
|
}
|
|
|
|
if (canCopy(type)) {
|
|
//TODO copy images? html? see ClipBoard
|
|
add(SimpleAction(ACTION_COPY, R.string.copy, R.drawable.ic_copy, messageContent!!.body))
|
|
}
|
|
|
|
if (event.canReact()) {
|
|
add(SimpleAction(ACTION_ADD_REACTION, R.string.message_add_reaction, R.drawable.ic_add_reaction, eventId))
|
|
}
|
|
|
|
if (canQuote(event, messageContent)) {
|
|
add(SimpleAction(ACTION_QUOTE, R.string.quote, R.drawable.ic_quote, eventId))
|
|
}
|
|
|
|
if (canViewReactions(event)) {
|
|
add(SimpleAction(ACTION_VIEW_REACTIONS, R.string.message_view_reaction, R.drawable.ic_view_reactions, informationData))
|
|
}
|
|
|
|
if (canShare(type)) {
|
|
if (messageContent is MessageImageContent) {
|
|
add(
|
|
SimpleAction(ACTION_SHARE,
|
|
R.string.share, R.drawable.ic_share,
|
|
session.contentUrlResolver().resolveFullSize(messageContent.url))
|
|
)
|
|
}
|
|
//TODO
|
|
}
|
|
|
|
|
|
if (event.root.sendState == SendState.SENT) {
|
|
|
|
//TODO Can be redacted
|
|
|
|
//TODO sent by me or sufficient power level
|
|
}
|
|
}
|
|
|
|
add(SimpleAction(VIEW_SOURCE, R.string.view_source, R.drawable.ic_view_source, event.root.toContentStringWithIndent()))
|
|
if (event.isEncrypted()) {
|
|
val decryptedContent = event.root.toClearContentStringWithIndent()
|
|
?: stringProvider.getString(R.string.encryption_information_decryption_error)
|
|
add(SimpleAction(VIEW_DECRYPTED_SOURCE, R.string.view_decrypted_source, R.drawable.ic_view_source, decryptedContent))
|
|
}
|
|
add(SimpleAction(ACTION_COPY_PERMALINK, R.string.permalink, R.drawable.ic_permalink, event.root.eventId))
|
|
|
|
if (session.myUserId != event.root.senderId && event.root.getClearType() == EventType.MESSAGE) {
|
|
//not sent by me
|
|
add(SimpleAction(ACTION_FLAG, R.string.report_content, R.drawable.ic_flag, event.root.eventId))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun canCancel(event: TimelineEvent): Boolean {
|
|
return false
|
|
}
|
|
|
|
private fun canReply(event: TimelineEvent, messageContent: MessageContent?): Boolean {
|
|
//Only event of type Event.EVENT_TYPE_MESSAGE are supported for the moment
|
|
if (event.root.getClearType() != EventType.MESSAGE) return false
|
|
return when (messageContent?.type) {
|
|
MessageType.MSGTYPE_TEXT,
|
|
MessageType.MSGTYPE_NOTICE,
|
|
MessageType.MSGTYPE_EMOTE,
|
|
MessageType.MSGTYPE_IMAGE,
|
|
MessageType.MSGTYPE_VIDEO,
|
|
MessageType.MSGTYPE_AUDIO,
|
|
MessageType.MSGTYPE_FILE -> true
|
|
else -> false
|
|
}
|
|
}
|
|
|
|
private fun canQuote(event: TimelineEvent, messageContent: MessageContent?): Boolean {
|
|
//Only event of type Event.EVENT_TYPE_MESSAGE are supported for the moment
|
|
if (event.root.getClearType() != EventType.MESSAGE) return false
|
|
return when (messageContent?.type) {
|
|
MessageType.MSGTYPE_TEXT,
|
|
MessageType.MSGTYPE_NOTICE,
|
|
MessageType.MSGTYPE_EMOTE,
|
|
MessageType.FORMAT_MATRIX_HTML,
|
|
MessageType.MSGTYPE_LOCATION -> {
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
}
|
|
|
|
private fun canRedact(event: TimelineEvent, myUserId: String): Boolean {
|
|
//Only event of type Event.EVENT_TYPE_MESSAGE are supported for the moment
|
|
if (event.root.getClearType() != EventType.MESSAGE) return false
|
|
//TODO if user is admin or moderator
|
|
return event.root.senderId == myUserId
|
|
}
|
|
|
|
private fun canRetry(event: TimelineEvent): Boolean {
|
|
return event.root.sendState.hasFailed() && event.root.isTextMessage()
|
|
}
|
|
|
|
|
|
private fun canViewReactions(event: TimelineEvent): Boolean {
|
|
//Only event of type Event.EVENT_TYPE_MESSAGE are supported for the moment
|
|
if (event.root.getClearType() != EventType.MESSAGE) return false
|
|
//TODO if user is admin or moderator
|
|
return event.annotations?.reactionsSummary?.any { isSingleEmoji(it.key) } ?: false
|
|
}
|
|
|
|
|
|
private fun canEdit(event: TimelineEvent, myUserId: String): Boolean {
|
|
//Only event of type Event.EVENT_TYPE_MESSAGE are supported for the moment
|
|
if (event.root.getClearType() != EventType.MESSAGE) return false
|
|
//TODO if user is admin or moderator
|
|
val messageContent = event.root.getClearContent().toModel<MessageContent>()
|
|
return event.root.senderId == myUserId && (
|
|
messageContent?.type == MessageType.MSGTYPE_TEXT
|
|
|| messageContent?.type == MessageType.MSGTYPE_EMOTE
|
|
)
|
|
}
|
|
|
|
|
|
private fun canCopy(type: String?): Boolean {
|
|
return when (type) {
|
|
MessageType.MSGTYPE_TEXT,
|
|
MessageType.MSGTYPE_NOTICE,
|
|
MessageType.MSGTYPE_EMOTE,
|
|
MessageType.FORMAT_MATRIX_HTML,
|
|
MessageType.MSGTYPE_LOCATION -> {
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
}
|
|
|
|
|
|
private fun canShare(type: String?): Boolean {
|
|
return when (type) {
|
|
MessageType.MSGTYPE_IMAGE,
|
|
MessageType.MSGTYPE_AUDIO,
|
|
MessageType.MSGTYPE_VIDEO -> {
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
}
|
|
}
|