matrixion/src/ChatPage.cc

859 lines
30 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 <QApplication>
2017-04-06 02:06:42 +03:00
#include <QDebug>
#include <QSettings>
#include <QtConcurrent>
2017-04-06 02:06:42 +03:00
#include "AvatarProvider.h"
2017-10-28 15:46:39 +03:00
#include "Cache.h"
2017-04-06 02:06:42 +03:00
#include "ChatPage.h"
#include "MainWindow.h"
2017-10-28 15:46:39 +03:00
#include "MatrixClient.h"
#include "OverlayModal.h"
#include "QuickSwitcher.h"
#include "RoomList.h"
#include "SideBarActions.h"
2017-05-19 19:55:38 +03:00
#include "Splitter.h"
2017-10-28 15:46:39 +03:00
#include "TextInputWidget.h"
2017-05-19 19:55:38 +03:00
#include "Theme.h"
2017-10-28 15:46:39 +03:00
#include "TopRoomBar.h"
#include "TypingDisplay.h"
2017-04-06 02:06:42 +03:00
#include "UserInfoWidget.h"
#include "UserSettingsPage.h"
2017-04-06 02:06:42 +03:00
2018-01-03 19:05:49 +03:00
#include "dialogs/ReadReceipts.h"
2017-11-30 14:53:28 +03:00
#include "timeline/TimelineViewManager.h"
constexpr int SYNC_RETRY_TIMEOUT = 40 * 1000;
constexpr int INITIAL_SYNC_RETRY_TIMEOUT = 240 * 1000;
2017-10-20 22:32:48 +03:00
2018-01-03 19:05:49 +03:00
ChatPage *ChatPage::instance_ = nullptr;
ChatPage::ChatPage(QSharedPointer<MatrixClient> client,
QSharedPointer<UserSettings> userSettings,
QWidget *parent)
2017-08-20 13:47:22 +03:00
: QWidget(parent)
, client_(client)
, userSettings_{userSettings}
2017-04-06 02:06:42 +03:00
{
setObjectName("chatPage");
2017-05-19 19:55:38 +03:00
topLayout_ = new QHBoxLayout(this);
topLayout_->setSpacing(0);
topLayout_->setMargin(0);
2018-01-09 16:07:32 +03:00
communitiesSideBar_ = new QWidget(this);
communitiesSideBar_->setFixedWidth(ui::sidebar::CommunitiesSidebarSize);
communitiesSideBarLayout_ = new QVBoxLayout(communitiesSideBar_);
communitiesSideBarLayout_->setSpacing(0);
communitiesSideBarLayout_->setMargin(0);
communitiesList_ = new CommunitiesList(client, this);
communitiesSideBarLayout_->addWidget(communitiesList_);
// communitiesSideBarLayout_->addStretch(1);
topLayout_->addWidget(communitiesSideBar_);
auto splitter = new Splitter(this);
splitter->setHandleWidth(0);
topLayout_->addWidget(splitter);
// SideBar
2017-11-09 00:09:15 +03:00
sideBar_ = new QFrame(this);
2018-01-15 22:04:49 +03:00
sideBar_->setObjectName("sideBar");
sideBar_->setMinimumWidth(ui::sidebar::NormalSize);
sideBarLayout_ = new QVBoxLayout(sideBar_);
sideBarLayout_->setSpacing(0);
sideBarLayout_->setMargin(0);
2018-01-09 16:07:32 +03:00
sideBarTopWidget_ = new QWidget(sideBar_);
sidebarActions_ = new SideBarActions(this);
2017-11-02 01:41:13 +03:00
connect(
sidebarActions_, &SideBarActions::showSettings, this, &ChatPage::showUserSettingsPage);
2017-12-10 16:22:01 +03:00
connect(
sidebarActions_, &SideBarActions::joinRoom, client_.data(), &MatrixClient::joinRoom);
2017-12-12 00:00:37 +03:00
connect(
sidebarActions_, &SideBarActions::createRoom, client_.data(), &MatrixClient::createRoom);
2017-10-15 22:08:51 +03:00
2017-11-09 00:09:15 +03:00
user_info_widget_ = new UserInfoWidget(sideBar_);
room_list_ = new RoomList(client, userSettings_, sideBar_);
2017-11-09 00:09:15 +03:00
sideBarLayout_->addWidget(user_info_widget_);
sideBarLayout_->addWidget(room_list_);
sideBarLayout_->addWidget(sidebarActions_);
2018-01-09 16:07:32 +03:00
sideBarTopWidgetLayout_ = new QVBoxLayout(sideBarTopWidget_);
sideBarTopWidgetLayout_->setSpacing(0);
sideBarTopWidgetLayout_->setMargin(0);
// Content
content_ = new QFrame(this);
content_->setObjectName("mainContent");
contentLayout_ = new QVBoxLayout(content_);
contentLayout_->setSpacing(0);
contentLayout_->setMargin(0);
2017-11-09 00:09:15 +03:00
top_bar_ = new TopRoomBar(this);
view_manager_ = new TimelineViewManager(client, this);
2017-11-09 00:09:15 +03:00
contentLayout_->addWidget(top_bar_);
contentLayout_->addWidget(view_manager_);
// Splitter
splitter->addWidget(sideBar_);
splitter->addWidget(content_);
2017-11-09 01:17:08 +03:00
splitter->setSizes({ui::sidebar::NormalSize, parent->width() - ui::sidebar::NormalSize});
2017-10-04 11:33:34 +03:00
text_input_ = new TextInputWidget(this);
typingDisplay_ = new TypingDisplay(this);
contentLayout_->addWidget(typingDisplay_);
contentLayout_->addWidget(text_input_);
typingRefresher_ = new QTimer(this);
typingRefresher_->setInterval(TYPING_REFRESH_TIMEOUT);
connect(user_info_widget_, &UserInfoWidget::logout, this, [this]() {
client_->logout();
emit showOverlayProgressBar();
});
connect(client_.data(), &MatrixClient::loggedOut, this, &ChatPage::logout);
connect(top_bar_, &TopRoomBar::inviteUsers, this, [this](QStringList users) {
2017-12-11 00:59:50 +03:00
for (int ii = 0; ii < users.size(); ++ii) {
2018-02-28 22:14:41 +03:00
QTimer::singleShot(ii * 1000, this, [this, ii, users]() {
2017-12-11 00:59:50 +03:00
client_->inviteUser(current_room_, users.at(ii));
});
}
});
connect(room_list_, &RoomList::roomChanged, this, [this](const QString &roomid) {
2017-10-04 11:33:34 +03:00
QStringList users;
if (!userSettings_->isTypingNotificationsEnabled()) {
typingDisplay_->setUsers(users);
return;
}
if (typingUsers_.find(roomid) != typingUsers_.end())
2017-10-04 11:33:34 +03:00
users = typingUsers_[roomid];
typingDisplay_->setUsers(users);
});
connect(room_list_, &RoomList::roomChanged, text_input_, &TextInputWidget::stopTyping);
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);
2018-04-21 16:34:50 +03:00
connect(room_list_, &RoomList::acceptInvite, this, [this](const QString &room_id) {
view_manager_->addRoom(room_id);
client_->joinRoom(room_id);
room_list_->removeRoom(room_id, currentRoom() == room_id);
});
connect(room_list_, &RoomList::declineInvite, this, [this](const QString &room_id) {
client_->leaveRoom(room_id);
room_list_->removeRoom(room_id, currentRoom() == room_id);
});
2017-12-19 23:36:12 +03:00
connect(text_input_, &TextInputWidget::startedTyping, this, [this]() {
if (!userSettings_->isTypingNotificationsEnabled())
return;
typingRefresher_->start();
client_->sendTypingNotification(current_room_);
});
connect(text_input_, &TextInputWidget::stoppedTyping, this, [this]() {
if (!userSettings_->isTypingNotificationsEnabled())
return;
typingRefresher_->stop();
client_->removeTypingNotification(current_room_);
});
connect(typingRefresher_, &QTimer::timeout, this, [this]() {
if (!userSettings_->isTypingNotificationsEnabled())
return;
client_->sendTypingNotification(current_room_);
});
connect(view_manager_,
&TimelineViewManager::updateRoomsLastMessage,
room_list_,
&RoomList::updateRoomDescription);
connect(room_list_,
SIGNAL(totalUnreadMessageCountUpdated(int)),
this,
SLOT(showUnreadMessageNotification(int)));
connect(text_input_,
SIGNAL(sendTextMessage(const QString &)),
view_manager_,
SLOT(queueTextMessage(const QString &)));
connect(text_input_,
SIGNAL(sendEmoteMessage(const QString &)),
view_manager_,
SLOT(queueEmoteMessage(const QString &)));
2017-10-08 22:38:38 +03:00
connect(text_input_,
&TextInputWidget::sendJoinRoomRequest,
client_.data(),
&MatrixClient::joinRoom);
connect(text_input_,
&TextInputWidget::uploadImage,
this,
[this](QSharedPointer<QIODevice> data, const QString &fn) {
client_->uploadImage(current_room_, fn, data);
});
2017-09-10 12:58:00 +03:00
connect(text_input_,
&TextInputWidget::uploadFile,
this,
[this](QSharedPointer<QIODevice> data, const QString &fn) {
client_->uploadFile(current_room_, fn, data);
});
2017-11-30 00:39:35 +03:00
connect(text_input_,
&TextInputWidget::uploadAudio,
this,
[this](QSharedPointer<QIODevice> data, const QString &fn) {
client_->uploadAudio(current_room_, fn, data);
});
connect(text_input_,
&TextInputWidget::uploadVideo,
this,
[this](QSharedPointer<QIODevice> data, const QString &fn) {
client_->uploadVideo(current_room_, fn, data);
});
2017-12-01 18:33:49 +03:00
2017-12-12 00:00:37 +03:00
connect(
client_.data(), &MatrixClient::roomCreationFailed, this, &ChatPage::showNotification);
2017-10-08 22:38:38 +03:00
connect(client_.data(), &MatrixClient::joinFailed, this, &ChatPage::showNotification);
connect(client_.data(), &MatrixClient::uploadFailed, this, [this](int, const QString &msg) {
2018-02-19 01:17:54 +03:00
text_input_->hideUploadSpinner();
emit showNotification(msg);
});
connect(
client_.data(),
&MatrixClient::imageUploaded,
this,
[this](QString roomid, QString filename, QString url, QString mime, uint64_t dsize) {
text_input_->hideUploadSpinner();
view_manager_->queueImageMessage(roomid, filename, url, mime, dsize);
});
connect(
client_.data(),
&MatrixClient::fileUploaded,
this,
[this](QString roomid, QString filename, QString url, QString mime, uint64_t dsize) {
text_input_->hideUploadSpinner();
view_manager_->queueFileMessage(roomid, filename, url, mime, dsize);
});
connect(
client_.data(),
&MatrixClient::audioUploaded,
this,
[this](QString roomid, QString filename, QString url, QString mime, uint64_t dsize) {
text_input_->hideUploadSpinner();
view_manager_->queueAudioMessage(roomid, filename, url, mime, dsize);
});
connect(
client_.data(),
&MatrixClient::videoUploaded,
this,
[this](QString roomid, QString filename, QString url, QString mime, uint64_t dsize) {
text_input_->hideUploadSpinner();
view_manager_->queueVideoMessage(roomid, filename, url, mime, dsize);
});
2017-09-10 12:58:00 +03:00
2017-12-22 01:00:48 +03:00
connect(room_list_, &RoomList::roomAvatarChanged, this, &ChatPage::updateTopBarAvatar);
connect(client_.data(),
&MatrixClient::initialSyncCompleted,
this,
&ChatPage::initialSyncCompleted);
connect(
client_.data(), &MatrixClient::initialSyncFailed, this, &ChatPage::retryInitialSync);
connect(client_.data(), &MatrixClient::syncCompleted, this, &ChatPage::syncCompleted);
connect(client_.data(),
&MatrixClient::getOwnProfileResponse,
this,
&ChatPage::updateOwnProfileInfo);
2018-01-09 16:07:32 +03:00
connect(client_.data(),
SIGNAL(getOwnCommunitiesResponse(QList<QString>)),
this,
SLOT(updateOwnCommunitiesInfo(QList<QString>)));
connect(client_.data(),
&MatrixClient::communityProfileRetrieved,
this,
[this](QString communityId, QJsonObject profile) {
communities_[communityId]->parseProfile(profile);
2018-01-09 16:07:32 +03:00
});
connect(client_.data(),
&MatrixClient::communityRoomsRetrieved,
this,
[this](QString communityId, QJsonObject rooms) {
communities_[communityId]->parseRooms(rooms);
2018-01-09 16:07:32 +03:00
if (communityId == current_community_) {
if (communityId == "world") {
room_list_->setFilterRooms(false);
} else {
room_list_->setRoomFilter(
communities_[communityId]->getRoomList());
2018-01-09 16:07:32 +03:00
}
}
});
connect(client_.data(), &MatrixClient::joinedRoom, this, [this](const QString &room_id) {
2017-10-08 22:38:38 +03:00
emit showNotification("You joined the room.");
2018-04-21 16:34:50 +03:00
// We remove any invites with the same room_id.
try {
cache_->removeInvite(room_id.toStdString());
} catch (const lmdb::error &e) {
emit showNotification(QString("Failed to remove invite: %1")
.arg(QString::fromStdString(e.what())));
}
2017-10-08 22:38:38 +03:00
});
2018-04-21 16:34:50 +03:00
connect(client_.data(), &MatrixClient::leftRoom, this, &ChatPage::removeRoom);
connect(client_.data(), &MatrixClient::invitedUser, this, [this](QString, QString user) {
2017-12-11 00:59:50 +03:00
emit showNotification(QString("Invited user %1").arg(user));
});
connect(client_.data(), &MatrixClient::roomCreated, this, [this](QString room_id) {
2017-12-12 00:00:37 +03:00
emit showNotification(QString("Room %1 created").arg(room_id));
});
2018-03-17 22:23:46 +03:00
connect(client_.data(), &MatrixClient::redactionFailed, this, [this](const QString &error) {
emit showNotification(QString("Message redaction failed: %1").arg(error));
});
showContentTimer_ = new QTimer(this);
showContentTimer_->setSingleShot(true);
connect(showContentTimer_, &QTimer::timeout, this, [this]() {
consensusTimer_->stop();
emit contentLoaded();
});
2017-10-07 20:50:32 +03:00
consensusTimer_ = new QTimer(this);
connect(consensusTimer_, &QTimer::timeout, this, [this]() {
2017-10-07 20:50:32 +03:00
if (view_manager_->hasLoaded()) {
// Remove the spinner overlay.
emit contentLoaded();
showContentTimer_->stop();
2017-10-07 20:50:32 +03:00
consensusTimer_->stop();
}
});
initialSyncTimer_ = new QTimer(this);
connect(initialSyncTimer_, &QTimer::timeout, this, [this]() { retryInitialSync(); });
syncTimeoutTimer_ = new QTimer(this);
connect(syncTimeoutTimer_, &QTimer::timeout, this, [this]() {
if (client_->getHomeServer().isEmpty()) {
syncTimeoutTimer_->stop();
return;
}
qDebug() << "Sync took too long. Retrying...";
client_->sync();
});
2018-01-09 16:07:32 +03:00
connect(communitiesList_,
&CommunitiesList::communityChanged,
this,
[this](const QString &communityId) {
2018-01-09 16:07:32 +03:00
current_community_ = communityId;
if (communityId == "world")
2018-01-09 16:07:32 +03:00
room_list_->setFilterRooms(false);
else
room_list_->setRoomFilter(communities_[communityId]->getRoomList());
2018-01-09 16:07:32 +03:00
});
setGroupViewState(userSettings_->isGroupViewEnabled());
connect(userSettings_.data(),
&UserSettings::groupViewStateChanged,
this,
&ChatPage::setGroupViewState);
2018-04-21 16:34:50 +03:00
connect(this, &ChatPage::continueSync, this, [this](const QString &next_batch) {
syncTimeoutTimer_->start(SYNC_RETRY_TIMEOUT);
client_->setNextBatchToken(next_batch);
client_->sync();
});
connect(this, &ChatPage::startConsesusTimer, this, [this]() {
consensusTimer_->start(CONSENSUS_TIMEOUT);
showContentTimer_->start(SHOW_CONTENT_TIMEOUT);
});
connect(this, &ChatPage::initializeRoomList, room_list_, &RoomList::initialize);
connect(this,
&ChatPage::initializeViews,
view_manager_,
[this](const mtx::responses::Rooms &rooms) { view_manager_->initialize(rooms); });
connect(
this,
&ChatPage::initializeEmptyViews,
this,
[this](const std::vector<std::string> &rooms) { view_manager_->initialize(rooms); });
connect(this, &ChatPage::syncUI, this, [this](const mtx::responses::Rooms &rooms) {
2018-04-22 14:19:05 +03:00
try {
room_list_->cleanupInvites(cache_->invites());
} catch (const lmdb::error &e) {
qWarning() << "failed to retrieve invites" << e.what();
}
2018-04-21 16:34:50 +03:00
view_manager_->initialize(rooms);
removeLeftRooms(rooms.leave);
2018-04-21 17:14:16 +03:00
for (const auto &room : rooms.join) {
auto room_id = QString::fromStdString(room.first);
updateTypingUsers(room_id, room.second.ephemeral.typing);
updateRoomNotificationCount(
room_id, room.second.unread_notifications.notification_count);
}
2018-04-21 16:34:50 +03:00
});
connect(this, &ChatPage::syncRoomlist, room_list_, &RoomList::sync);
2018-01-03 19:05:49 +03:00
instance_ = this;
2018-04-21 16:34:50 +03:00
qRegisterMetaType<std::map<QString, RoomInfo>>();
qRegisterMetaType<QMap<QString, RoomInfo>>();
qRegisterMetaType<mtx::responses::Rooms>();
qRegisterMetaType<std::vector<std::string>>();
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::logout()
{
2017-10-20 22:32:48 +03:00
deleteConfigs();
resetUI();
2018-04-24 23:57:49 +03:00
emit closing();
2017-10-20 22:32:48 +03:00
}
void
ChatPage::resetUI()
{
room_list_->clear();
top_bar_->reset();
user_info_widget_->reset();
view_manager_->clearAll();
showUnreadMessageNotification(0);
2017-10-20 22:32:48 +03:00
}
void
ChatPage::deleteConfigs()
{
QSettings settings;
settings.beginGroup("auth");
settings.remove("");
settings.endGroup();
settings.beginGroup("client");
settings.remove("");
settings.endGroup();
settings.beginGroup("notifications");
settings.remove("");
settings.endGroup();
cache_->deleteData();
client_->reset();
}
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();
2018-01-09 16:07:32 +03:00
client_->getOwnCommunities();
cache_ = QSharedPointer<Cache>(new Cache(userid));
2017-12-22 01:00:48 +03:00
room_list_->setCache(cache_);
2018-04-21 16:34:50 +03:00
text_input_->setCache(cache_);
2018-04-21 21:18:57 +03:00
AvatarProvider::init(client_, cache_);
try {
cache_->setup();
if (!cache_->isFormatValid()) {
cache_->deleteData();
cache_->setup();
cache_->setCurrentFormat();
}
if (cache_->isInitialized()) {
loadStateFromCache();
return;
}
} catch (const lmdb::error &e) {
qCritical() << "Cache failure" << e.what();
cache_->deleteData();
qInfo() << "Falling back to initial sync ...";
}
client_->initialSync();
initialSyncTimer_->start(INITIAL_SYNC_RETRY_TIMEOUT);
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::syncCompleted(const mtx::responses::Sync &response)
2017-04-06 02:06:42 +03:00
{
syncTimeoutTimer_->stop();
2018-04-22 15:37:23 +03:00
QtConcurrent::run([this, res = std::move(response)]() {
2018-04-21 16:34:50 +03:00
try {
cache_->saveState(res);
2018-04-22 14:19:05 +03:00
emit syncUI(res.rooms);
2018-04-21 16:34:50 +03:00
emit syncRoomlist(cache_->roomUpdates(res));
} catch (const lmdb::error &e) {
std::cout << "save cache error:" << e.what() << '\n';
// TODO: retry sync.
return;
}
2018-04-21 16:34:50 +03:00
emit continueSync(cache_->nextBatchToken());
});
2017-04-06 02:06:42 +03:00
}
2017-08-20 13:47:22 +03:00
void
ChatPage::initialSyncCompleted(const mtx::responses::Sync &response)
2017-04-06 02:06:42 +03:00
{
initialSyncTimer_->stop();
2018-04-21 16:34:50 +03:00
qDebug() << "initial sync completed";
2018-04-21 16:34:50 +03:00
QtConcurrent::run([this, res = std::move(response)]() {
try {
cache_->saveState(res);
2018-04-22 10:54:52 +03:00
emit initializeViews(std::move(res.rooms));
2018-04-21 16:34:50 +03:00
emit initializeRoomList(cache_->roomInfo());
} catch (const lmdb::error &e) {
qWarning() << "cache error:" << QString::fromStdString(e.what());
emit retryInitialSync();
return;
}
2018-04-21 16:34:50 +03:00
emit continueSync(cache_->nextBatchToken());
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
{
if (current_room_ != roomid)
return;
2017-04-06 02:06:42 +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();
2017-04-06 02:06:42 +03:00
user_info_widget_->setUserId(userid);
user_info_widget_->setDisplayName(display_name);
2017-04-06 02:06:42 +03:00
2018-04-21 21:18:57 +03:00
if (!avatar_url.isValid())
return;
2018-03-25 23:05:44 +03:00
2018-04-21 21:18:57 +03:00
if (!cache_.isNull()) {
auto data = cache_->image(avatar_url.toString());
if (!data.isNull()) {
user_info_widget_->setAvatar(QImage::fromData(data));
2018-03-25 15:59:47 +03:00
return;
2018-04-21 21:18:57 +03:00
}
2018-03-25 15:59:47 +03:00
}
2018-04-21 21:18:57 +03:00
auto proxy = client_->fetchUserAvatar(avatar_url);
if (proxy.isNull())
return;
proxy->setParent(this);
connect(proxy.data(),
&DownloadMediaProxy::avatarDownloaded,
this,
[this, proxy](const QImage &img) {
proxy->deleteLater();
user_info_widget_->setAvatar(img);
});
2017-04-06 02:06:42 +03:00
}
2018-01-09 16:07:32 +03:00
void
ChatPage::updateOwnCommunitiesInfo(const QList<QString> &own_communities)
{
for (int i = 0; i < own_communities.size(); i++) {
QSharedPointer<Community> community = QSharedPointer<Community>(new Community());
communities_[own_communities[i]] = community;
2018-01-09 16:07:32 +03:00
}
communitiesList_->setCommunities(communities_);
2018-01-09 16:07:32 +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 (room_id.isEmpty()) {
qWarning() << "can't switch to empty room_id";
return;
}
2018-04-21 16:34:50 +03:00
try {
auto room_info = cache_->getRoomInfo({room_id.toStdString()});
2017-04-06 02:06:42 +03:00
2018-04-21 16:34:50 +03:00
if (room_info.find(room_id) == room_info.end())
return;
2018-04-21 16:34:50 +03:00
const auto name = QString::fromStdString(room_info[room_id].name);
const auto avatar_url = QString::fromStdString(room_info[room_id].avatar_url);
2018-04-21 16:34:50 +03:00
top_bar_->updateRoomName(name);
top_bar_->updateRoomTopic(QString::fromStdString(room_info[room_id].topic));
auto img = cache_->getRoomAvatar(room_id);
if (img.isNull())
2018-04-21 16:34:50 +03:00
top_bar_->updateRoomAvatarFromName(name);
else
top_bar_->updateRoomAvatar(img);
2018-04-21 16:34:50 +03:00
} catch (const lmdb::error &e) {
qWarning() << "failed to change top bar room info" << e.what();
2018-04-21 16:34:50 +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)
{
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::loadStateFromCache()
{
2018-04-21 16:34:50 +03:00
qDebug() << "restoring state from cache";
2018-04-21 16:34:50 +03:00
QtConcurrent::run([this]() {
try {
cache_->populateMembers();
2018-04-21 16:34:50 +03:00
emit initializeEmptyViews(cache_->joinedRooms());
2018-04-21 21:18:57 +03:00
emit initializeRoomList(cache_->roomInfo());
2018-04-21 16:34:50 +03:00
} catch (const lmdb::error &e) {
std::cout << "load cache error:" << e.what() << '\n';
// TODO Clear cache and restart.
return;
}
2018-04-21 16:34:50 +03:00
// Start receiving events.
emit continueSync(cache_->nextBatchToken());
2018-04-21 16:34:50 +03:00
// Check periodically if the timelines have been loaded.
emit startConsesusTimer();
});
}
2017-08-20 13:47:22 +03:00
void
ChatPage::showQuickSwitcher()
2017-08-15 21:06:27 +03:00
{
2017-10-07 20:09:34 +03:00
if (quickSwitcher_.isNull()) {
quickSwitcher_ = QSharedPointer<QuickSwitcher>(
new QuickSwitcher(this),
[](QuickSwitcher *switcher) { switcher->deleteLater(); });
2017-10-07 20:09:34 +03:00
connect(quickSwitcher_.data(),
&QuickSwitcher::roomSelected,
room_list_,
&RoomList::highlightSelectedRoom);
2017-10-07 20:09:34 +03:00
connect(quickSwitcher_.data(), &QuickSwitcher::closing, this, [this]() {
if (!quickSwitcherModal_.isNull())
quickSwitcherModal_->hide();
text_input_->setFocus(Qt::FocusReason::PopupFocusReason);
});
}
2017-10-07 20:09:34 +03:00
if (quickSwitcherModal_.isNull()) {
quickSwitcherModal_ = QSharedPointer<OverlayModal>(
new OverlayModal(MainWindow::instance(), quickSwitcher_.data()),
[](OverlayModal *modal) { modal->deleteLater(); });
2017-11-22 22:13:22 +03:00
quickSwitcherModal_->setColor(QColor(30, 30, 30, 170));
}
try {
std::map<QString, QString> rooms;
auto info = cache_->roomInfo(false);
2018-04-21 16:34:50 +03:00
for (auto it = info.begin(); it != info.end(); ++it)
rooms.emplace(QString::fromStdString(it.value().name).trimmed(), it.key());
2018-04-21 16:34:50 +03:00
quickSwitcher_->setRoomList(rooms);
quickSwitcherModal_->show();
} catch (const lmdb::error &e) {
2018-04-21 16:34:50 +03:00
const auto err = QString::fromStdString(e.what());
emit showNotification(QString("Failed to load room list: %1").arg(err));
}
}
2017-12-19 23:36:12 +03:00
void
2018-04-21 16:34:50 +03:00
ChatPage::removeRoom(const QString &room_id)
2017-12-19 23:36:12 +03:00
{
try {
2018-04-21 16:34:50 +03:00
cache_->removeRoom(room_id);
cache_->removeInvite(room_id.toStdString());
2017-12-19 23:36:12 +03:00
} catch (const lmdb::error &e) {
qCritical() << "The cache couldn't be updated: " << e.what();
// TODO: Notify the user.
}
room_list_->removeRoom(room_id, room_id == current_room_);
}
2017-10-04 11:33:34 +03:00
void
ChatPage::updateTypingUsers(const QString &roomid, const std::vector<std::string> &user_ids)
2017-10-04 11:33:34 +03:00
{
if (!userSettings_->isTypingNotificationsEnabled())
return;
typingUsers_[roomid] = generateTypingUsers(roomid, user_ids);
if (current_room_ == roomid)
typingDisplay_->setUsers(typingUsers_[roomid]);
}
QStringList
ChatPage::generateTypingUsers(const QString &room_id, const std::vector<std::string> &typing_users)
{
2017-10-04 11:33:34 +03:00
QStringList users;
QSettings settings;
QString local_user = settings.value("auth/user_id").toString();
for (const auto &uid : typing_users) {
const auto remote_user = QString::fromStdString(uid);
if (remote_user == local_user)
continue;
users.append(Cache::displayName(room_id, remote_user));
}
2017-10-04 11:33:34 +03:00
users.sort();
return users;
2017-10-04 11:33:34 +03:00
}
void
ChatPage::removeLeftRooms(const std::map<std::string, mtx::responses::LeftRoom> &rooms)
{
for (auto it = rooms.cbegin(); it != rooms.cend(); ++it) {
const auto room_id = QString::fromStdString(it->first);
2018-04-21 16:34:50 +03:00
room_list_->removeRoom(room_id, room_id == current_room_);
}
}
2018-01-03 19:05:49 +03:00
void
ChatPage::showReadReceipts(const QString &event_id)
{
if (receiptsDialog_.isNull()) {
receiptsDialog_ = QSharedPointer<dialogs::ReadReceipts>(
new dialogs::ReadReceipts(this),
[](dialogs::ReadReceipts *dialog) { dialog->deleteLater(); });
2018-01-03 19:05:49 +03:00
}
if (receiptsModal_.isNull()) {
receiptsModal_ = QSharedPointer<OverlayModal>(
new OverlayModal(MainWindow::instance(), receiptsDialog_.data()),
[](OverlayModal *modal) { modal->deleteLater(); });
2018-01-03 19:05:49 +03:00
receiptsModal_->setColor(QColor(30, 30, 30, 170));
}
receiptsDialog_->addUsers(cache_->readReceipts(event_id, current_room_));
receiptsModal_->show();
2018-01-03 19:05:49 +03:00
}
void
ChatPage::setGroupViewState(bool isEnabled)
{
if (!isEnabled) {
communitiesList_->communityChanged("world");
communitiesSideBar_->hide();
return;
}
communitiesSideBar_->show();
}
void
ChatPage::retryInitialSync(int status_code)
{
initialSyncTimer_->stop();
if (client_->getHomeServer().isEmpty()) {
deleteConfigs();
resetUI();
emit showLoginPage("Sync error. Please try again.");
return;
}
// Retry on Bad-Gateway & Gateway-Timeout errors
if (status_code == -1 || status_code == 504 || status_code == 502 || status_code == 524) {
qWarning() << "retrying initial sync";
client_->initialSync();
initialSyncTimer_->start(INITIAL_SYNC_RETRY_TIMEOUT);
} else {
// Drop into the login screen.
deleteConfigs();
resetUI();
emit showLoginPage(QString("Sync error %1. Please try again.").arg(status_code));
}
}
void
ChatPage::updateRoomNotificationCount(const QString &room_id, uint16_t notification_count)
{
room_list_->updateUnreadMessageCount(room_id, notification_count);
}