matrixion/src/ChatPage.cc

616 lines
16 KiB
C++
Raw Normal View History

2017-04-06 02:06:42 +03:00
/*
* nheko Copyright (C) 2017 Konstantinos Sideris <siderisk@auth.gr>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <QDebug>
#include <QSettings>
#include "ChatPage.h"
2017-05-19 19:55:38 +03:00
#include "Splitter.h"
2017-04-06 02:06:42 +03:00
#include "Sync.h"
2017-05-19 19:55:38 +03:00
#include "Theme.h"
2017-05-08 19:44:01 +03:00
#include "TimelineViewManager.h"
2017-04-06 02:06:42 +03:00
#include "UserInfoWidget.h"
#include "AliasesEventContent.h"
#include "AvatarEventContent.h"
#include "AvatarProvider.h"
#include "CanonicalAliasEventContent.h"
#include "CreateEventContent.h"
#include "HistoryVisibilityEventContent.h"
#include "JoinRulesEventContent.h"
2017-08-15 21:06:27 +03:00
#include "MainWindow.h"
2017-05-08 19:44:01 +03:00
#include "MemberEventContent.h"
#include "NameEventContent.h"
#include "PowerLevelsEventContent.h"
#include "TopicEventContent.h"
#include "StateEvent.h"
namespace events = matrix::events;
ChatPage::ChatPage(QSharedPointer<MatrixClient> client, QWidget *parent)
2017-08-20 13:47:22 +03:00
: QWidget(parent)
, sync_interval_(2000)
, client_(client)
2017-04-06 02:06:42 +03:00
{
2017-05-19 19:55:38 +03:00
setStyleSheet("background-color: #f8fbfe;");
topLayout_ = new QHBoxLayout(this);
topLayout_->setSpacing(0);
topLayout_->setMargin(0);
auto splitter = new Splitter(this);
splitter->setHandleWidth(0);
topLayout_->addWidget(splitter);
// SideBar
sideBar_ = new QWidget(this);
sideBar_->setMinimumSize(QSize(ui::sidebar::NormalSize, 0));
sideBarLayout_ = new QVBoxLayout(sideBar_);
sideBarLayout_->setSpacing(0);
sideBarLayout_->setMargin(0);
sideBarTopLayout_ = new QVBoxLayout();
sideBarTopLayout_->setSpacing(0);
sideBarTopLayout_->setMargin(0);
sideBarMainLayout_ = new QVBoxLayout();
sideBarMainLayout_->setSpacing(0);
sideBarMainLayout_->setMargin(0);
sideBarLayout_->addLayout(sideBarTopLayout_);
sideBarLayout_->addLayout(sideBarMainLayout_);
sideBarTopWidget_ = new QWidget(sideBar_);
sideBarTopWidget_->setStyleSheet("background-color: #d6dde3; color: #ebebeb;");
sideBarTopLayout_->addWidget(sideBarTopWidget_);
sideBarTopWidgetLayout_ = new QVBoxLayout(sideBarTopWidget_);
sideBarTopWidgetLayout_->setSpacing(0);
sideBarTopWidgetLayout_->setMargin(0);
// Content
content_ = new QWidget(this);
contentLayout_ = new QVBoxLayout(content_);
contentLayout_->setSpacing(0);
contentLayout_->setMargin(0);
topBarLayout_ = new QHBoxLayout();
topBarLayout_->setSpacing(0);
mainContentLayout_ = new QVBoxLayout();
mainContentLayout_->setSpacing(0);
mainContentLayout_->setMargin(0);
contentLayout_->addLayout(topBarLayout_);
contentLayout_->addLayout(mainContentLayout_);
// Splitter
splitter->addWidget(sideBar_);
splitter->addWidget(content_);
2017-04-06 02:06:42 +03:00
room_list_ = new RoomList(client, sideBar_);
2017-05-19 19:55:38 +03:00
sideBarMainLayout_->addWidget(room_list_);
2017-04-06 02:06:42 +03:00
top_bar_ = new TopRoomBar(this);
2017-05-19 19:55:38 +03:00
topBarLayout_->addWidget(top_bar_);
2017-04-06 02:06:42 +03:00
view_manager_ = new TimelineViewManager(client, this);
2017-05-19 19:55:38 +03:00
mainContentLayout_->addWidget(view_manager_);
2017-04-06 02:06:42 +03:00
text_input_ = new TextInputWidget(this);
2017-05-19 19:55:38 +03:00
contentLayout_->addWidget(text_input_);
2017-04-06 02:06:42 +03:00
2017-05-19 19:55:38 +03:00
user_info_widget_ = new UserInfoWidget(sideBarTopWidget_);
sideBarTopWidgetLayout_->addWidget(user_info_widget_);
2017-04-06 02:06:42 +03:00
2017-04-06 15:17:58 +03:00
sync_timer_ = new QTimer(this);
2017-04-11 02:35:09 +03:00
sync_timer_->setSingleShot(true);
2017-04-06 15:17:58 +03:00
connect(sync_timer_, SIGNAL(timeout()), this, SLOT(startSync()));
connect(user_info_widget_, SIGNAL(logout()), client_.data(), SLOT(logout()));
connect(client_.data(), SIGNAL(loggedOut()), this, SLOT(logout()));
connect(room_list_, &RoomList::roomChanged, this, &ChatPage::changeTopRoomInfo);
connect(room_list_, &RoomList::roomChanged, text_input_, &TextInputWidget::focusLineEdit);
connect(room_list_, &RoomList::roomChanged, view_manager_, &TimelineViewManager::setHistoryView);
2017-04-06 02:06:42 +03:00
2017-05-31 17:06:03 +03:00
connect(view_manager_, &TimelineViewManager::unreadMessages, this, [=](const QString &roomid, int count) {
if (!settingsManager_.contains(roomid)) {
qWarning() << "RoomId does not have settings" << roomid;
room_list_->updateUnreadMessageCount(roomid, count);
return;
}
if (settingsManager_[roomid]->isNotificationsEnabled())
room_list_->updateUnreadMessageCount(roomid, count);
});
connect(view_manager_,
&TimelineViewManager::updateRoomsLastMessage,
room_list_,
&RoomList::updateRoomDescription);
connect(room_list_,
SIGNAL(totalUnreadMessageCountUpdated(int)),
this,
SLOT(showUnreadMessageNotification(int)));
2017-04-06 02:06:42 +03:00
connect(text_input_,
SIGNAL(sendTextMessage(const QString &)),
view_manager_,
2017-04-06 02:06:42 +03:00
SLOT(sendTextMessage(const QString &)));
connect(client_.data(),
SIGNAL(roomAvatarRetrieved(const QString &, const QPixmap &)),
this,
SLOT(updateTopBarAvatar(const QString &, const QPixmap &)));
connect(client_.data(),
2017-04-11 02:35:09 +03:00
SIGNAL(initialSyncCompleted(const SyncResponse &)),
2017-04-06 02:06:42 +03:00
this,
2017-04-11 02:35:09 +03:00
SLOT(initialSyncCompleted(const SyncResponse &)));
connect(client_.data(),
2017-04-11 02:35:09 +03:00
SIGNAL(syncCompleted(const SyncResponse &)),
2017-04-06 02:06:42 +03:00
this,
2017-04-11 02:35:09 +03:00
SLOT(syncCompleted(const SyncResponse &)));
2017-08-20 13:47:22 +03:00
connect(client_.data(), SIGNAL(syncFailed(const QString &)), this, SLOT(syncFailed(const QString &)));
connect(client_.data(),
2017-04-11 02:35:09 +03:00
SIGNAL(getOwnProfileResponse(const QUrl &, const QString &)),
this,
SLOT(updateOwnProfileInfo(const QUrl &, const QString &)));
2017-08-20 13:47:22 +03:00
connect(client_.data(), SIGNAL(ownAvatarRetrieved(const QPixmap &)), this, SLOT(setOwnAvatar(const QPixmap &)));
AvatarProvider::init(client);
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::logout()
{
sync_timer_->stop();
2017-05-31 17:06:03 +03:00
// Delete all config parameters.
QSettings settings;
2017-05-31 17:06:03 +03:00
settings.beginGroup("auth");
settings.remove("");
settings.endGroup();
settings.beginGroup("client");
settings.remove("");
settings.endGroup();
settings.beginGroup("notifications");
settings.remove("");
settings.endGroup();
// Clear the environment.
room_list_->clear();
view_manager_->clearAll();
top_bar_->reset();
user_info_widget_->reset();
client_->reset();
2017-05-16 15:23:31 +03:00
state_manager_.clear();
2017-05-31 17:06:03 +03:00
settingsManager_.clear();
room_avatars_.clear();
AvatarProvider::clear();
emit close();
}
2017-08-20 13:47:22 +03:00
void
ChatPage::bootstrap(QString userid, QString homeserver, QString token)
2017-04-06 02:06:42 +03:00
{
client_->setServer(homeserver);
client_->setAccessToken(token);
client_->getOwnProfile();
try {
cache_ = QSharedPointer<Cache>(new Cache(userid));
} catch (const std::exception &e) {
qCritical() << e.what();
}
if (cache_->isInitialized())
loadStateFromCache();
else
client_->initialSync();
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::startSync()
2017-04-06 02:06:42 +03:00
{
client_->sync();
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::setOwnAvatar(const QPixmap &img)
2017-04-06 02:06:42 +03:00
{
user_info_widget_->setAvatar(img.toImage());
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::syncFailed(const QString &msg)
2017-04-11 02:35:09 +03:00
{
qWarning() << "Sync error:" << msg;
sync_timer_->start(sync_interval_ * 5);
}
// TODO: Should be moved in another class that manages this global list.
2017-08-20 13:47:22 +03:00
void
ChatPage::updateDisplayNames(const RoomState &state)
{
for (const auto member : state.memberships) {
auto displayName = member.content().displayName();
if (!displayName.isEmpty())
TimelineViewManager::DISPLAY_NAMES.insert(member.stateKey(), displayName);
}
}
2017-08-20 13:47:22 +03:00
void
ChatPage::syncCompleted(const SyncResponse &response)
2017-04-06 02:06:42 +03:00
{
// TODO: Catch exception
cache_->setNextBatchToken(response.nextBatch());
client_->setNextBatchToken(response.nextBatch());
2017-04-06 02:06:42 +03:00
auto joined = response.rooms().join();
for (auto it = joined.constBegin(); it != joined.constEnd(); it++) {
RoomState room_state;
// Merge the new updates for rooms that we are tracking.
if (state_manager_.contains(it.key()))
room_state = state_manager_[it.key()];
updateRoomState(room_state, it.value().state().events());
updateRoomState(room_state, it.value().timeline().events());
updateDisplayNames(room_state);
try {
cache_->insertRoomState(it.key(), room_state);
} catch (const lmdb::error &e) {
qCritical() << e.what();
// Stop using the cache if an errors occurs.
// TODO: Should also be marked as invalid and be deleted.
cache_->unmount();
}
if (state_manager_.contains(it.key())) {
// TODO: Use pointers instead of copying.
auto oldState = state_manager_[it.key()];
oldState.update(room_state);
state_manager_.insert(it.key(), oldState);
} else {
qWarning() << "New rooms cannot be added after initial sync, yet.";
}
if (it.key() == current_room_)
changeTopRoomInfo(it.key());
}
room_list_->sync(state_manager_);
2017-04-06 02:06:42 +03:00
view_manager_->sync(response.rooms());
2017-04-11 02:35:09 +03:00
sync_timer_->start(sync_interval_);
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::initialSyncCompleted(const SyncResponse &response)
2017-04-06 02:06:42 +03:00
{
if (!response.nextBatch().isEmpty())
client_->setNextBatchToken(response.nextBatch());
2017-04-06 02:06:42 +03:00
auto joined = response.rooms().join();
// TODO: Catch exception
cache_->setNextBatchToken(response.nextBatch());
for (auto it = joined.constBegin(); it != joined.constEnd(); it++) {
RoomState room_state;
// Build the current state from the timeline and state events.
updateRoomState(room_state, it.value().state().events());
updateRoomState(room_state, it.value().timeline().events());
// Remove redundant memberships.
room_state.removeLeaveMemberships();
// Resolve room name and avatar. e.g in case of one-to-one chats.
room_state.resolveName();
room_state.resolveAvatar();
try {
cache_->insertRoomState(it.key(), room_state);
} catch (const lmdb::error &e) {
qCritical() << e.what();
// Stop using the cache if an errors occurs.
// TODO: Should also be marked as invalid and be deleted.
cache_->unmount();
}
updateDisplayNames(room_state);
state_manager_.insert(it.key(), room_state);
2017-05-31 17:06:03 +03:00
settingsManager_.insert(it.key(), QSharedPointer<RoomSettings>(new RoomSettings(it.key())));
for (const auto membership : room_state.memberships) {
auto uid = membership.sender();
auto url = membership.content().avatarUrl();
if (!url.toString().isEmpty())
AvatarProvider::setAvatarUrl(uid, url);
}
}
// Populate timelines with messages.
2017-04-06 02:06:42 +03:00
view_manager_->initialize(response.rooms());
// Initialize room list.
2017-05-31 19:42:07 +03:00
room_list_->setInitialRooms(settingsManager_, state_manager_);
2017-04-06 02:06:42 +03:00
sync_timer_->start(sync_interval_);
emit contentLoaded();
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::updateTopBarAvatar(const QString &roomid, const QPixmap &img)
2017-04-06 02:06:42 +03:00
{
room_avatars_.insert(roomid, img);
2017-04-06 02:06:42 +03:00
if (current_room_ != roomid)
2017-04-06 02:06:42 +03:00
return;
2017-04-12 17:14:53 +03:00
top_bar_->updateRoomAvatar(img.toImage());
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::updateOwnProfileInfo(const QUrl &avatar_url, const QString &display_name)
2017-04-06 02:06:42 +03:00
{
QSettings settings;
auto userid = settings.value("auth/user_id").toString();
user_info_widget_->setUserId(userid);
user_info_widget_->setDisplayName(display_name);
if (avatar_url.isValid())
client_->fetchOwnAvatar(avatar_url);
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::changeTopRoomInfo(const QString &room_id)
2017-04-06 02:06:42 +03:00
{
if (!state_manager_.contains(room_id))
return;
2017-04-06 02:06:42 +03:00
auto state = state_manager_[room_id];
top_bar_->updateRoomName(state.getName());
top_bar_->updateRoomTopic(state.getTopic());
2017-05-31 17:06:03 +03:00
top_bar_->setRoomSettings(settingsManager_[room_id]);
if (room_avatars_.contains(room_id))
top_bar_->updateRoomAvatar(room_avatars_.value(room_id).toImage());
2017-04-12 01:29:25 +03:00
else
top_bar_->updateRoomAvatarFromName(state.getName());
2017-04-06 02:06:42 +03:00
current_room_ = room_id;
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::showUnreadMessageNotification(int count)
{
2017-05-21 16:36:06 +03:00
emit unreadMessages(count);
// TODO: Make the default title a const.
if (count == 0)
emit changeWindowTitle("nheko");
else
emit changeWindowTitle(QString("nheko (%1)").arg(count));
}
2017-08-20 13:47:22 +03:00
void
ChatPage::updateRoomState(RoomState &room_state, const QJsonArray &events)
{
events::EventType ty;
for (const auto &event : events) {
try {
ty = events::extractEventType(event.toObject());
} catch (const DeserializationException &e) {
qWarning() << e.what() << event;
continue;
}
if (!events::isStateEvent(ty))
continue;
try {
switch (ty) {
case events::EventType::RoomAliases: {
events::StateEvent<events::AliasesEventContent> aliases;
aliases.deserialize(event);
room_state.aliases = aliases;
break;
}
case events::EventType::RoomAvatar: {
events::StateEvent<events::AvatarEventContent> avatar;
avatar.deserialize(event);
room_state.avatar = avatar;
break;
}
case events::EventType::RoomCanonicalAlias: {
events::StateEvent<events::CanonicalAliasEventContent> canonical_alias;
canonical_alias.deserialize(event);
room_state.canonical_alias = canonical_alias;
break;
}
case events::EventType::RoomCreate: {
events::StateEvent<events::CreateEventContent> create;
create.deserialize(event);
room_state.create = create;
break;
}
case events::EventType::RoomHistoryVisibility: {
events::StateEvent<events::HistoryVisibilityEventContent> history_visibility;
history_visibility.deserialize(event);
room_state.history_visibility = history_visibility;
break;
}
case events::EventType::RoomJoinRules: {
events::StateEvent<events::JoinRulesEventContent> join_rules;
join_rules.deserialize(event);
room_state.join_rules = join_rules;
break;
}
case events::EventType::RoomName: {
events::StateEvent<events::NameEventContent> name;
name.deserialize(event);
room_state.name = name;
break;
}
2017-05-08 19:44:01 +03:00
case events::EventType::RoomMember: {
events::StateEvent<events::MemberEventContent> member;
member.deserialize(event);
room_state.memberships.insert(member.stateKey(), member);
2017-05-10 18:04:57 +03:00
2017-05-08 19:44:01 +03:00
break;
}
case events::EventType::RoomPowerLevels: {
events::StateEvent<events::PowerLevelsEventContent> power_levels;
power_levels.deserialize(event);
room_state.power_levels = power_levels;
break;
}
case events::EventType::RoomTopic: {
events::StateEvent<events::TopicEventContent> topic;
topic.deserialize(event);
room_state.topic = topic;
break;
}
default: {
continue;
}
}
} catch (const DeserializationException &e) {
qWarning() << e.what() << event;
continue;
}
}
}
2017-08-20 13:47:22 +03:00
void
ChatPage::loadStateFromCache()
{
qDebug() << "Restoring state from cache";
try {
qDebug() << "Restored nextBatchToken" << cache_->nextBatchToken();
client_->setNextBatchToken(cache_->nextBatchToken());
} catch (const lmdb::error &e) {
qCritical() << "Failed to load next_batch_token from cache" << e.what();
// TODO: Clean the environment
return;
}
// Fetch all the joined room's state.
auto rooms = cache_->states();
for (auto it = rooms.constBegin(); it != rooms.constEnd(); it++) {
RoomState room_state = it.value();
// Clean up and prepare state for use.
room_state.removeLeaveMemberships();
room_state.resolveName();
room_state.resolveAvatar();
// Update the global list with user's display names.
updateDisplayNames(room_state);
// Save the current room state.
state_manager_.insert(it.key(), room_state);
// Create or restore the settings for this room.
settingsManager_.insert(it.key(), QSharedPointer<RoomSettings>(new RoomSettings(it.key())));
// Resolve user avatars.
for (const auto membership : room_state.memberships) {
auto uid = membership.sender();
auto url = membership.content().avatarUrl();
if (!url.toString().isEmpty())
AvatarProvider::setAvatarUrl(uid, url);
}
}
// Initializing empty timelines.
view_manager_->initialize(rooms.keys());
// Initialize room list from the restored state and settings.
room_list_->setInitialRooms(settingsManager_, state_manager_);
// Remove the spinner overlay.
emit contentLoaded();
sync_timer_->start(sync_interval_);
}
2017-08-20 13:47:22 +03:00
void
ChatPage::keyPressEvent(QKeyEvent *event)
2017-08-15 21:06:27 +03:00
{
if (event->key() == Qt::Key_K) {
if (event->modifiers() == Qt::ControlModifier)
showQuickSwitcher();
}
}
2017-08-20 13:47:22 +03:00
void
ChatPage::showQuickSwitcher()
2017-08-15 21:06:27 +03:00
{
if (quickSwitcher_ == nullptr) {
quickSwitcher_ = new QuickSwitcher(this);
connect(quickSwitcher_, &QuickSwitcher::roomSelected, room_list_, &RoomList::highlightSelectedRoom);
connect(quickSwitcher_, &QuickSwitcher::closing, this, [=]() {
if (this->quickSwitcherModal_ != nullptr)
this->quickSwitcherModal_->fadeOut();
});
}
if (quickSwitcherModal_ == nullptr) {
quickSwitcherModal_ = new OverlayModal(MainWindow::instance(), quickSwitcher_);
quickSwitcherModal_->setDuration(0);
quickSwitcherModal_->setColor(QColor(30, 30, 30, 170));
}
QMap<QString, QString> rooms;
for (auto it = state_manager_.constBegin(); it != state_manager_.constEnd(); ++it)
rooms.insert(it.value().getName(), it.key());
quickSwitcher_->setRoomList(rooms);
quickSwitcherModal_->fadeIn();
}
2017-04-06 02:06:42 +03:00
ChatPage::~ChatPage()
{
sync_timer_->stop();
}