2019-08-31 00:20:53 +03:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <QAbstractListModel>
|
|
|
|
#include <QColor>
|
2019-09-01 23:58:26 +03:00
|
|
|
#include <QDate>
|
2019-08-31 23:43:31 +03:00
|
|
|
#include <QHash>
|
2019-09-18 23:58:25 +03:00
|
|
|
#include <QSet>
|
2019-08-31 00:20:53 +03:00
|
|
|
|
2019-12-15 05:19:33 +03:00
|
|
|
#include <mtxclient/http/errors.hpp>
|
2019-10-06 13:59:51 +03:00
|
|
|
|
2019-12-15 01:39:02 +03:00
|
|
|
#include "CacheCryptoStructs.h"
|
2020-07-10 00:15:22 +03:00
|
|
|
#include "EventStore.h"
|
2019-12-15 05:19:33 +03:00
|
|
|
|
|
|
|
namespace mtx::http {
|
|
|
|
using RequestErr = const std::optional<mtx::http::ClientError> &;
|
|
|
|
}
|
2020-01-31 08:12:02 +03:00
|
|
|
namespace mtx::responses {
|
|
|
|
struct Timeline;
|
|
|
|
struct Messages;
|
|
|
|
struct ClaimKeys;
|
|
|
|
}
|
2020-04-13 17:22:30 +03:00
|
|
|
struct RelatedInfo;
|
2019-09-11 01:00:04 +03:00
|
|
|
|
2019-09-03 00:28:05 +03:00
|
|
|
namespace qml_mtx_events {
|
|
|
|
Q_NAMESPACE
|
|
|
|
|
|
|
|
enum EventType
|
|
|
|
{
|
|
|
|
// Unsupported event
|
|
|
|
Unsupported,
|
|
|
|
/// m.room_key_request
|
|
|
|
KeyRequest,
|
2020-05-06 13:52:13 +03:00
|
|
|
/// m.reaction,
|
|
|
|
Reaction,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.aliases
|
|
|
|
Aliases,
|
|
|
|
/// m.room.avatar
|
|
|
|
Avatar,
|
2020-07-11 02:19:48 +03:00
|
|
|
/// m.call.invite
|
|
|
|
CallInvite,
|
|
|
|
/// m.call.answer
|
|
|
|
CallAnswer,
|
|
|
|
/// m.call.hangup
|
|
|
|
CallHangUp,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.canonical_alias
|
|
|
|
CanonicalAlias,
|
|
|
|
/// m.room.create
|
2020-02-29 03:27:51 +03:00
|
|
|
RoomCreate,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.encrypted.
|
|
|
|
Encrypted,
|
|
|
|
/// m.room.encryption.
|
|
|
|
Encryption,
|
|
|
|
/// m.room.guest_access
|
2020-02-29 03:27:51 +03:00
|
|
|
RoomGuestAccess,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.history_visibility
|
2020-02-29 03:27:51 +03:00
|
|
|
RoomHistoryVisibility,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.join_rules
|
2020-02-29 03:27:51 +03:00
|
|
|
RoomJoinRules,
|
2019-09-03 00:28:05 +03:00
|
|
|
/// m.room.member
|
|
|
|
Member,
|
|
|
|
/// m.room.name
|
|
|
|
Name,
|
|
|
|
/// m.room.power_levels
|
|
|
|
PowerLevels,
|
|
|
|
/// m.room.tombstone
|
|
|
|
Tombstone,
|
|
|
|
/// m.room.topic
|
|
|
|
Topic,
|
|
|
|
/// m.room.redaction
|
|
|
|
Redaction,
|
|
|
|
/// m.room.pinned_events
|
|
|
|
PinnedEvents,
|
|
|
|
// m.sticker
|
|
|
|
Sticker,
|
|
|
|
// m.tag
|
|
|
|
Tag,
|
|
|
|
/// m.room.message
|
|
|
|
AudioMessage,
|
|
|
|
EmoteMessage,
|
|
|
|
FileMessage,
|
|
|
|
ImageMessage,
|
|
|
|
LocationMessage,
|
|
|
|
NoticeMessage,
|
|
|
|
TextMessage,
|
|
|
|
VideoMessage,
|
2019-09-09 22:42:33 +03:00
|
|
|
Redacted,
|
2019-09-03 00:28:05 +03:00
|
|
|
UnknownMessage,
|
|
|
|
};
|
|
|
|
Q_ENUM_NS(EventType)
|
2019-09-18 23:58:25 +03:00
|
|
|
|
|
|
|
enum EventState
|
|
|
|
{
|
|
|
|
//! The plaintext message was received by the server.
|
|
|
|
Received,
|
|
|
|
//! At least one of the participants has read the message.
|
|
|
|
Read,
|
|
|
|
//! The client sent the message. Not yet received.
|
|
|
|
Sent,
|
|
|
|
//! When the message is loaded from cache or backfill.
|
|
|
|
Empty,
|
|
|
|
};
|
|
|
|
Q_ENUM_NS(EventState)
|
2019-09-03 00:28:05 +03:00
|
|
|
}
|
|
|
|
|
2019-09-19 23:44:25 +03:00
|
|
|
class StateKeeper
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
StateKeeper(std::function<void()> &&fn)
|
|
|
|
: fn_(std::move(fn))
|
|
|
|
{}
|
|
|
|
|
|
|
|
~StateKeeper() { fn_(); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::function<void()> fn_;
|
|
|
|
};
|
|
|
|
|
2019-09-08 17:50:32 +03:00
|
|
|
struct DecryptionResult
|
|
|
|
{
|
|
|
|
//! The decrypted content as a normal plaintext event.
|
|
|
|
mtx::events::collections::TimelineEvents event;
|
|
|
|
//! Whether or not the decryption was successful.
|
|
|
|
bool isDecrypted = false;
|
|
|
|
};
|
|
|
|
|
2019-10-03 19:07:01 +03:00
|
|
|
class TimelineViewManager;
|
|
|
|
|
2019-08-31 00:20:53 +03:00
|
|
|
class TimelineModel : public QAbstractListModel
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
2019-09-18 21:34:30 +03:00
|
|
|
Q_PROPERTY(
|
|
|
|
int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
|
2020-01-17 03:25:14 +03:00
|
|
|
Q_PROPERTY(std::vector<QString> typingUsers READ typingUsers WRITE updateTypingUsers NOTIFY
|
|
|
|
typingUsersChanged)
|
2020-04-13 17:22:30 +03:00
|
|
|
Q_PROPERTY(QString reply READ reply WRITE setReply NOTIFY replyChanged RESET resetReply)
|
2020-05-01 08:40:27 +03:00
|
|
|
Q_PROPERTY(
|
|
|
|
bool paginationInProgress READ paginationInProgress NOTIFY paginationInProgressChanged)
|
2019-08-31 00:20:53 +03:00
|
|
|
|
|
|
|
public:
|
2020-02-04 23:16:04 +03:00
|
|
|
explicit TimelineModel(TimelineViewManager *manager,
|
|
|
|
QString room_id,
|
|
|
|
QObject *parent = nullptr);
|
2019-08-31 00:20:53 +03:00
|
|
|
|
|
|
|
enum Roles
|
|
|
|
{
|
2019-09-01 15:17:33 +03:00
|
|
|
Section,
|
2019-08-31 00:20:53 +03:00
|
|
|
Type,
|
2020-01-23 22:59:17 +03:00
|
|
|
TypeString,
|
2020-05-19 22:04:38 +03:00
|
|
|
IsOnlyEmoji,
|
2019-08-31 00:20:53 +03:00
|
|
|
Body,
|
|
|
|
FormattedBody,
|
|
|
|
UserId,
|
|
|
|
UserName,
|
|
|
|
Timestamp,
|
2019-09-08 13:44:46 +03:00
|
|
|
Url,
|
2019-10-09 01:36:03 +03:00
|
|
|
ThumbnailUrl,
|
2020-03-01 21:55:43 +03:00
|
|
|
Blurhash,
|
2019-09-29 11:45:35 +03:00
|
|
|
Filename,
|
2019-10-04 02:10:46 +03:00
|
|
|
Filesize,
|
2019-09-29 11:45:35 +03:00
|
|
|
MimeType,
|
2019-09-08 13:44:46 +03:00
|
|
|
Height,
|
|
|
|
Width,
|
|
|
|
ProportionalHeight,
|
2019-09-08 16:26:46 +03:00
|
|
|
Id,
|
2019-09-18 23:58:25 +03:00
|
|
|
State,
|
2019-09-20 00:02:56 +03:00
|
|
|
IsEncrypted,
|
2020-05-15 03:35:29 +03:00
|
|
|
IsRoomEncrypted,
|
2019-11-05 19:16:04 +03:00
|
|
|
ReplyTo,
|
2020-05-04 14:14:54 +03:00
|
|
|
Reactions,
|
2020-02-29 03:27:51 +03:00
|
|
|
RoomId,
|
2019-12-10 16:46:52 +03:00
|
|
|
RoomName,
|
|
|
|
RoomTopic,
|
2020-07-24 20:30:12 +03:00
|
|
|
CallType,
|
2020-01-04 01:21:33 +03:00
|
|
|
Dump,
|
2019-08-31 00:20:53 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
QHash<int, QByteArray> roleNames() const override;
|
2019-09-03 00:28:05 +03:00
|
|
|
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
|
|
|
|
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
|
2020-07-10 00:15:22 +03:00
|
|
|
QVariant data(const mtx::events::collections::TimelineEvents &event, int role) const;
|
2019-08-31 00:20:53 +03:00
|
|
|
|
2020-01-06 18:42:56 +03:00
|
|
|
bool canFetchMore(const QModelIndex &) const override;
|
|
|
|
void fetchMore(const QModelIndex &) override;
|
|
|
|
|
2019-09-01 23:34:36 +03:00
|
|
|
Q_INVOKABLE QString displayName(QString id) const;
|
2019-09-07 23:22:07 +03:00
|
|
|
Q_INVOKABLE QString avatarUrl(QString id) const;
|
2019-09-01 23:58:26 +03:00
|
|
|
Q_INVOKABLE QString formatDateSeparator(QDate date) const;
|
2020-01-17 03:25:14 +03:00
|
|
|
Q_INVOKABLE QString formatTypingUsers(const std::vector<QString> &users, QColor bg);
|
2020-01-23 22:34:04 +03:00
|
|
|
Q_INVOKABLE QString formatMemberEvent(QString id);
|
2020-02-29 03:27:51 +03:00
|
|
|
Q_INVOKABLE QString formatJoinRuleEvent(QString id);
|
|
|
|
Q_INVOKABLE QString formatHistoryVisibilityEvent(QString id);
|
|
|
|
Q_INVOKABLE QString formatGuestAccessEvent(QString id);
|
|
|
|
Q_INVOKABLE QString formatPowerLevelEvent(QString id);
|
2019-10-03 19:07:01 +03:00
|
|
|
|
2019-09-07 03:01:44 +03:00
|
|
|
Q_INVOKABLE QString escapeEmoji(QString str) const;
|
2019-09-08 16:26:46 +03:00
|
|
|
Q_INVOKABLE void viewRawMessage(QString id) const;
|
2020-04-21 23:32:45 +03:00
|
|
|
Q_INVOKABLE void viewDecryptedRawMessage(QString id) const;
|
2019-11-03 04:09:36 +03:00
|
|
|
Q_INVOKABLE void openUserProfile(QString userid) const;
|
2019-09-11 01:54:40 +03:00
|
|
|
Q_INVOKABLE void replyAction(QString id);
|
2019-09-19 00:37:30 +03:00
|
|
|
Q_INVOKABLE void readReceiptsAction(QString id) const;
|
2019-09-29 13:29:17 +03:00
|
|
|
Q_INVOKABLE void redactEvent(QString id);
|
2019-09-18 21:34:30 +03:00
|
|
|
Q_INVOKABLE int idToIndex(QString id) const;
|
|
|
|
Q_INVOKABLE QString indexToId(int index) const;
|
2019-12-03 04:26:41 +03:00
|
|
|
Q_INVOKABLE void cacheMedia(QString eventId);
|
2020-03-20 16:05:12 +03:00
|
|
|
Q_INVOKABLE bool saveMedia(QString eventId) const;
|
2019-09-01 00:44:17 +03:00
|
|
|
|
2020-07-20 01:42:48 +03:00
|
|
|
std::vector<::Reaction> reactions(const std::string &event_id)
|
|
|
|
{
|
|
|
|
auto list = events.reactions(event_id);
|
|
|
|
std::vector<::Reaction> vec;
|
|
|
|
for (const auto &r : list)
|
|
|
|
vec.push_back(r.value<Reaction>());
|
|
|
|
return vec;
|
|
|
|
}
|
|
|
|
|
2020-04-24 02:21:20 +03:00
|
|
|
void updateLastMessage();
|
2019-08-31 23:43:31 +03:00
|
|
|
void addEvents(const mtx::responses::Timeline &events);
|
2019-09-11 01:00:04 +03:00
|
|
|
template<class T>
|
2020-07-11 02:19:48 +03:00
|
|
|
void sendMessageEvent(const T &content, mtx::events::EventType eventType);
|
2020-04-13 17:22:30 +03:00
|
|
|
RelatedInfo relatedInfo(QString id);
|
2019-08-31 23:43:31 +03:00
|
|
|
|
2019-09-01 00:44:17 +03:00
|
|
|
public slots:
|
2019-10-03 23:39:56 +03:00
|
|
|
void setCurrentIndex(int index);
|
2019-09-18 21:34:30 +03:00
|
|
|
int currentIndex() const { return idToIndex(currentId); }
|
2019-09-19 00:37:30 +03:00
|
|
|
void markEventsAsRead(const std::vector<QString> &event_ids);
|
2020-07-10 00:15:22 +03:00
|
|
|
QVariantMap getDump(QString eventId, QString relatedTo) const;
|
2020-01-17 03:25:14 +03:00
|
|
|
void updateTypingUsers(const std::vector<QString> &users)
|
|
|
|
{
|
|
|
|
if (this->typingUsers_ != users) {
|
|
|
|
this->typingUsers_ = users;
|
|
|
|
emit typingUsersChanged(typingUsers_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::vector<QString> typingUsers() const { return typingUsers_; }
|
2020-04-28 12:07:24 +03:00
|
|
|
bool paginationInProgress() const { return m_paginationInProgress; }
|
2020-04-13 17:22:30 +03:00
|
|
|
QString reply() const { return reply_; }
|
|
|
|
void setReply(QString newReply)
|
|
|
|
{
|
|
|
|
if (reply_ != newReply) {
|
|
|
|
reply_ = newReply;
|
|
|
|
emit replyChanged(reply_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void resetReply()
|
|
|
|
{
|
|
|
|
if (!reply_.isEmpty()) {
|
|
|
|
reply_ = "";
|
|
|
|
emit replyChanged(reply_);
|
|
|
|
}
|
|
|
|
}
|
2020-04-24 02:21:20 +03:00
|
|
|
void setDecryptDescription(bool decrypt) { decryptDescription = decrypt; }
|
2020-08-10 00:36:47 +03:00
|
|
|
void clearTimeline() { events.clearTimeline(); }
|
2020-04-13 17:22:30 +03:00
|
|
|
|
2019-09-01 00:44:17 +03:00
|
|
|
private slots:
|
2019-11-10 02:30:02 +03:00
|
|
|
void addPendingMessage(mtx::events::collections::TimelineEvents event);
|
2019-09-01 00:44:17 +03:00
|
|
|
|
|
|
|
signals:
|
2019-09-18 21:34:30 +03:00
|
|
|
void currentIndexChanged(int index);
|
2019-09-29 13:29:17 +03:00
|
|
|
void redactionFailed(QString id);
|
|
|
|
void eventRedacted(QString id);
|
2019-12-03 04:26:41 +03:00
|
|
|
void mediaCached(QString mxcUrl, QString cacheUrl);
|
2019-12-04 01:34:16 +03:00
|
|
|
void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
|
2020-01-17 03:25:14 +03:00
|
|
|
void typingUsersChanged(std::vector<QString> users);
|
2020-04-13 17:22:30 +03:00
|
|
|
void replyChanged(QString reply);
|
2020-04-28 12:07:24 +03:00
|
|
|
void paginationInProgressChanged(const bool);
|
2020-07-11 02:19:48 +03:00
|
|
|
void newCallEvent(const mtx::events::collections::TimelineEvents &event);
|
2019-09-01 00:44:17 +03:00
|
|
|
|
2020-07-18 18:43:49 +03:00
|
|
|
void newMessageToSend(mtx::events::collections::TimelineEvents event);
|
|
|
|
void addPendingMessageToStore(mtx::events::collections::TimelineEvents event);
|
|
|
|
|
2019-08-31 00:20:53 +03:00
|
|
|
private:
|
2020-07-11 02:19:48 +03:00
|
|
|
void sendEncryptedMessageEvent(const std::string &txn_id,
|
|
|
|
nlohmann::json content,
|
|
|
|
mtx::events::EventType);
|
2019-09-19 23:44:25 +03:00
|
|
|
void handleClaimedKeys(std::shared_ptr<StateKeeper> keeper,
|
|
|
|
const std::map<std::string, std::string> &room_key,
|
|
|
|
const std::map<std::string, DevicePublicKeys> &pks,
|
|
|
|
const std::string &user_id,
|
|
|
|
const mtx::responses::ClaimKeys &res,
|
|
|
|
mtx::http::RequestErr err);
|
2019-10-31 16:09:51 +03:00
|
|
|
void readEvent(const std::string &id);
|
2019-09-08 17:50:32 +03:00
|
|
|
|
2020-04-28 12:07:24 +03:00
|
|
|
void setPaginationInProgress(const bool paginationInProgress);
|
|
|
|
|
2020-04-17 02:02:32 +03:00
|
|
|
QSet<QString> read;
|
2019-08-31 00:20:53 +03:00
|
|
|
|
2020-07-10 00:15:22 +03:00
|
|
|
mutable EventStore events;
|
|
|
|
|
2019-09-01 00:44:17 +03:00
|
|
|
QString room_id_;
|
|
|
|
|
2020-05-01 08:40:27 +03:00
|
|
|
bool decryptDescription = true;
|
2020-04-28 12:07:24 +03:00
|
|
|
bool m_paginationInProgress = false;
|
2019-09-01 00:44:17 +03:00
|
|
|
|
2019-09-18 21:34:30 +03:00
|
|
|
QString currentId;
|
2020-04-13 17:22:30 +03:00
|
|
|
QString reply_;
|
2020-01-17 03:25:14 +03:00
|
|
|
std::vector<QString> typingUsers_;
|
2019-10-03 19:07:01 +03:00
|
|
|
|
|
|
|
TimelineViewManager *manager_;
|
2019-11-10 02:30:02 +03:00
|
|
|
|
|
|
|
friend struct SendMessageVisitor;
|
2019-08-31 00:20:53 +03:00
|
|
|
};
|
2019-09-11 01:00:04 +03:00
|
|
|
|
|
|
|
template<class T>
|
|
|
|
void
|
2020-07-11 02:19:48 +03:00
|
|
|
TimelineModel::sendMessageEvent(const T &content, mtx::events::EventType eventType)
|
2019-09-11 01:00:04 +03:00
|
|
|
{
|
2019-09-18 23:58:25 +03:00
|
|
|
mtx::events::RoomEvent<T> msgCopy = {};
|
2020-07-11 02:19:48 +03:00
|
|
|
msgCopy.content = content;
|
|
|
|
msgCopy.type = eventType;
|
2019-11-10 02:30:02 +03:00
|
|
|
emit newMessageToSend(msgCopy);
|
2019-09-11 01:00:04 +03:00
|
|
|
}
|