/* * nheko Copyright (C) 2017 Konstantinos Sideris * * 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 . */ #include #include #include #include #include #include #include #include "AvatarProvider.h" #include "Cache.h" #include "Cache_p.h" #include "CallManager.h" #include "ChatPage.h" #include "DeviceVerificationFlow.h" #include "EventAccessors.h" #include "Logging.h" #include "MainWindow.h" #include "MatrixClient.h" #include "Olm.h" #include "QuickSwitcher.h" #include "RoomList.h" #include "SideBarActions.h" #include "Splitter.h" #include "UserInfoWidget.h" #include "UserSettingsPage.h" #include "Utils.h" #include "ui/OverlayModal.h" #include "ui/Theme.h" #include "notifications/Manager.h" #include "dialogs/ReadReceipts.h" #include "popups/UserMentions.h" #include "timeline/TimelineViewManager.h" #include "blurhash.hpp" // TODO: Needs to be updated with an actual secret. static const std::string STORAGE_SECRET_KEY("secret"); ChatPage *ChatPage::instance_ = nullptr; constexpr int CHECK_CONNECTIVITY_INTERVAL = 15'000; constexpr int RETRY_TIMEOUT = 5'000; constexpr size_t MAX_ONETIME_KEYS = 50; Q_DECLARE_METATYPE(std::optional) Q_DECLARE_METATYPE(std::optional) Q_DECLARE_METATYPE(mtx::presence::PresenceState) Q_DECLARE_METATYPE(mtx::secret_storage::AesHmacSha2KeyDescription) Q_DECLARE_METATYPE(SecretsToDecrypt) ChatPage::ChatPage(QSharedPointer userSettings, QWidget *parent) : QWidget(parent) , isConnected_(true) , userSettings_{userSettings} , notificationsManager(this) , callManager_(new CallManager(this)) { setObjectName("chatPage"); instance_ = this; qRegisterMetaType>(); qRegisterMetaType>(); qRegisterMetaType(); qRegisterMetaType(); qRegisterMetaType(); topLayout_ = new QHBoxLayout(this); topLayout_->setSpacing(0); topLayout_->setMargin(0); communitiesList_ = new CommunitiesList(this); topLayout_->addWidget(communitiesList_); splitter = new Splitter(this); splitter->setHandleWidth(0); topLayout_->addWidget(splitter); // SideBar sideBar_ = new QFrame(this); sideBar_->setObjectName("sideBar"); sideBar_->setMinimumWidth(::splitter::calculateSidebarSizes(QFont{}).normal); sideBarLayout_ = new QVBoxLayout(sideBar_); sideBarLayout_->setSpacing(0); sideBarLayout_->setMargin(0); sideBarTopWidget_ = new QWidget(sideBar_); sidebarActions_ = new SideBarActions(this); connect( sidebarActions_, &SideBarActions::showSettings, this, &ChatPage::showUserSettingsPage); connect(sidebarActions_, &SideBarActions::joinRoom, this, &ChatPage::joinRoom); connect(sidebarActions_, &SideBarActions::createRoom, this, &ChatPage::createRoom); user_info_widget_ = new UserInfoWidget(sideBar_); connect(user_info_widget_, &UserInfoWidget::openGlobalUserProfile, this, [this]() { view_manager_->activeTimeline()->openUserProfile(utils::localUser(), true); }); user_mentions_popup_ = new popups::UserMentions(); room_list_ = new RoomList(userSettings, sideBar_); connect(room_list_, &RoomList::joinRoom, this, &ChatPage::joinRoom); sideBarLayout_->addWidget(user_info_widget_); sideBarLayout_->addWidget(room_list_); sideBarLayout_->addWidget(sidebarActions_); 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); view_manager_ = new TimelineViewManager(callManager_, this); contentLayout_->addWidget(view_manager_->getWidget()); // Splitter splitter->addWidget(sideBar_); splitter->addWidget(content_); splitter->restoreSizes(parent->width()); connect(this, &ChatPage::downloadedSecrets, this, &ChatPage::decryptDownloadedSecrets, Qt::QueuedConnection); connect(this, &ChatPage::connectionLost, this, [this]() { nhlog::net()->info("connectivity lost"); isConnected_ = false; http::client()->shutdown(); }); connect(this, &ChatPage::connectionRestored, this, [this]() { nhlog::net()->info("trying to re-connect"); isConnected_ = true; // Drop all pending connections. http::client()->shutdown(); trySync(); }); connect( new QShortcut(QKeySequence("Ctrl+Down"), this), &QShortcut::activated, this, [this]() { if (isVisible()) room_list_->nextRoom(); }); connect( new QShortcut(QKeySequence("Ctrl+Up"), this), &QShortcut::activated, this, [this]() { if (isVisible()) room_list_->previousRoom(); }); connectivityTimer_.setInterval(CHECK_CONNECTIVITY_INTERVAL); connect(&connectivityTimer_, &QTimer::timeout, this, [=]() { if (http::client()->access_token().empty()) { connectivityTimer_.stop(); return; } http::client()->versions( [this](const mtx::responses::Versions &, mtx::http::RequestErr err) { if (err) { emit connectionLost(); return; } if (!isConnected_) emit connectionRestored(); }); }); connect(this, &ChatPage::loggedOut, this, &ChatPage::logout); connect( view_manager_, &TimelineViewManager::showRoomList, splitter, &Splitter::showFullRoomList); connect(view_manager_, &TimelineViewManager::inviteUsers, this, [this](QStringList users) { const auto room_id = current_room_.toStdString(); for (int ii = 0; ii < users.size(); ++ii) { QTimer::singleShot(ii * 500, this, [this, room_id, ii, users]() { const auto user = users.at(ii); http::client()->invite_user( room_id, user.toStdString(), [this, user](const mtx::responses::RoomInvite &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to invite user: %1").arg(user)); return; } emit showNotification(tr("Invited user: %1").arg(user)); }); }); } }); connect(room_list_, &RoomList::roomChanged, this, [this](QString room_id) { this->current_room_ = room_id; }); connect(room_list_, &RoomList::roomChanged, splitter, &Splitter::showChatView); connect( room_list_, &RoomList::roomChanged, view_manager_, &TimelineViewManager::setHistoryView); connect(room_list_, &RoomList::acceptInvite, this, [this](const QString &room_id) { joinRoom(room_id); room_list_->removeRoom(room_id, currentRoom() == room_id); }); connect(room_list_, &RoomList::declineInvite, this, [this](const QString &room_id) { leaveRoom(room_id); room_list_->removeRoom(room_id, currentRoom() == room_id); }); connect(view_manager_, &TimelineViewManager::updateRoomsLastMessage, room_list_, &RoomList::updateRoomDescription); connect(room_list_, SIGNAL(totalUnreadMessageCountUpdated(int)), this, SIGNAL(unreadMessages(int))); connect( this, &ChatPage::updateGroupsInfo, communitiesList_, &CommunitiesList::setCommunities); connect(this, &ChatPage::leftRoom, this, &ChatPage::removeRoom); connect(this, &ChatPage::notificationsRetrieved, this, &ChatPage::sendNotifications); connect(this, &ChatPage::highlightedNotifsRetrieved, this, [](const mtx::responses::Notifications ¬if) { try { cache::saveTimelineMentions(notif); } catch (const lmdb::error &e) { nhlog::db()->error("failed to save mentions: {}", e.what()); } }); connect(communitiesList_, &CommunitiesList::communityChanged, this, [this](const QString &groupId) { current_community_ = groupId; if (groupId == "world") { auto hidden = communitiesList_->hiddenTagsAndCommunities(); std::set roomsToHide = communitiesList_->roomList(groupId); for (const auto &hiddenTag : hidden) { auto temp = communitiesList_->roomList(hiddenTag); roomsToHide.insert(temp.begin(), temp.end()); } room_list_->removeFilter(roomsToHide); } else { auto hidden = communitiesList_->hiddenTagsAndCommunities(); hidden.erase(current_community_); auto roomsToShow = communitiesList_->roomList(groupId); for (const auto &hiddenTag : hidden) { for (const auto &r : communitiesList_->roomList(hiddenTag)) roomsToShow.erase(r); } room_list_->applyFilter(roomsToShow); } }); connect(¬ificationsManager, &NotificationsManager::notificationClicked, this, [this](const QString &roomid, const QString &eventid) { Q_UNUSED(eventid) room_list_->highlightSelectedRoom(roomid); activateWindow(); }); connect(¬ificationsManager, &NotificationsManager::sendNotificationReply, this, [this](const QString &roomid, const QString &eventid, const QString &body) { view_manager_->queueReply(roomid, eventid, body); room_list_->highlightSelectedRoom(roomid); activateWindow(); }); setGroupViewState(userSettings_->groupView()); connect(userSettings_.data(), &UserSettings::groupViewStateChanged, this, &ChatPage::setGroupViewState); connect(this, &ChatPage::initializeRoomList, room_list_, &RoomList::initialize); connect( this, &ChatPage::initializeViews, view_manager_, [this](const mtx::responses::Rooms &rooms) { view_manager_->sync(rooms); }, Qt::QueuedConnection); connect(this, &ChatPage::initializeEmptyViews, view_manager_, &TimelineViewManager::initWithMessages); connect(this, &ChatPage::initializeMentions, user_mentions_popup_, &popups::UserMentions::initializeMentions); connect( this, &ChatPage::chatFocusChanged, view_manager_, &TimelineViewManager::chatFocusChanged); connect(this, &ChatPage::syncUI, this, [this](const mtx::responses::Rooms &rooms) { try { room_list_->cleanupInvites(cache::invites()); } catch (const lmdb::error &e) { nhlog::db()->error("failed to retrieve invites: {}", e.what()); } view_manager_->sync(rooms); removeLeftRooms(rooms.leave); bool hasNotifications = false; for (const auto &room : rooms.join) { auto room_id = QString::fromStdString(room.first); updateRoomNotificationCount( room_id, room.second.unread_notifications.notification_count, room.second.unread_notifications.highlight_count); if (room.second.unread_notifications.notification_count > 0) hasNotifications = true; } if (hasNotifications && userSettings_->hasNotifications()) http::client()->notifications( 5, "", "", [this](const mtx::responses::Notifications &res, mtx::http::RequestErr err) { if (err) { nhlog::net()->warn( "failed to retrieve notifications: {} ({})", err->matrix_error.error, static_cast(err->status_code)); return; } emit notificationsRetrieved(std::move(res)); }); }); connect(this, &ChatPage::syncRoomlist, room_list_, &RoomList::sync); connect(this, &ChatPage::syncTags, communitiesList_, &CommunitiesList::syncTags); // Callbacks to update the user info (top left corner of the page). connect(this, &ChatPage::setUserAvatar, user_info_widget_, &UserInfoWidget::setAvatar); connect(this, &ChatPage::setUserDisplayName, this, [this](const QString &name) { auto userid = utils::localUser(); user_info_widget_->setUserId(userid); user_info_widget_->setDisplayName(name); }); connect( this, &ChatPage::tryInitialSyncCb, this, &ChatPage::tryInitialSync, Qt::QueuedConnection); connect(this, &ChatPage::trySyncCb, this, &ChatPage::trySync, Qt::QueuedConnection); connect( this, &ChatPage::tryDelayedSyncCb, this, [this]() { QTimer::singleShot(RETRY_TIMEOUT, this, &ChatPage::trySync); }, Qt::QueuedConnection); connect(this, &ChatPage::newSyncResponse, this, &ChatPage::handleSyncResponse, Qt::QueuedConnection); connect(this, &ChatPage::dropToLoginPageCb, this, &ChatPage::dropToLoginPage); connectCallMessage(); connectCallMessage(); connectCallMessage(); connectCallMessage(); } void ChatPage::logout() { resetUI(); deleteConfigs(); emit closing(); connectivityTimer_.stop(); } void ChatPage::dropToLoginPage(const QString &msg) { nhlog::ui()->info("dropping to the login page: {}", msg.toStdString()); http::client()->shutdown(); connectivityTimer_.stop(); resetUI(); deleteConfigs(); emit showLoginPage(msg); } void ChatPage::resetUI() { room_list_->clear(); user_info_widget_->reset(); view_manager_->clearAll(); emit unreadMessages(0); } void ChatPage::deleteConfigs() { QSettings settings; QString profilePrefix = (UserSettings::instance()->profile() == "default" ? "" : QString("profile/%1").arg(UserSettings::instance()->profile())); settings.beginGroup(profilePrefix); settings.beginGroup("auth"); settings.remove(""); settings.endGroup(); // auth settings.endGroup(); // profilePrefix http::client()->shutdown(); cache::deleteData(); } void ChatPage::bootstrap(QString userid, QString homeserver, QString token) { using namespace mtx::identifiers; try { http::client()->set_user(parse(userid.toStdString())); } catch (const std::invalid_argument &) { nhlog::ui()->critical("bootstrapped with invalid user_id: {}", userid.toStdString()); } http::client()->set_server(homeserver.toStdString()); http::client()->set_access_token(token.toStdString()); // The Olm client needs the user_id & device_id that will be included // in the generated payloads & keys. olm::client()->set_user_id(http::client()->user_id().to_string()); olm::client()->set_device_id(http::client()->device_id()); try { cache::init(userid); connect(cache::client(), &Cache::newReadReceipts, view_manager_, &TimelineViewManager::updateReadReceipts); connect( cache::client(), &Cache::roomReadStatus, room_list_, &RoomList::updateReadStatus); connect(cache::client(), &Cache::removeNotification, ¬ificationsManager, &NotificationsManager::removeNotification); const bool isInitialized = cache::isInitialized(); const auto cacheVersion = cache::formatVersion(); callManager_->refreshTurnServer(); if (!isInitialized) { cache::setCurrentFormat(); } else { if (cacheVersion == cache::CacheVersion::Current) { loadStateFromCache(); return; } else if (cacheVersion == cache::CacheVersion::Older) { if (!cache::runMigrations()) { QMessageBox::critical( this, tr("Cache migration failed!"), tr("Migrating the cache to the current version failed. " "This can have different reasons. Please open an " "issue and try to use an older version in the mean " "time. Alternatively you can try deleting the cache " "manually.")); QCoreApplication::quit(); } loadStateFromCache(); return; } else if (cacheVersion == cache::CacheVersion::Newer) { QMessageBox::critical( this, tr("Incompatible cache version"), tr("The cache on your disk is newer than this version of Nheko " "supports. Please update or clear your cache.")); QCoreApplication::quit(); return; } } } catch (const lmdb::error &e) { nhlog::db()->critical("failure during boot: {}", e.what()); cache::deleteData(); nhlog::net()->info("falling back to initial sync"); } try { // It's the first time syncing with this device // There isn't a saved olm account to restore. nhlog::crypto()->info("creating new olm account"); olm::client()->create_new_account(); cache::saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY)); } catch (const lmdb::error &e) { nhlog::crypto()->critical("failed to save olm account {}", e.what()); emit dropToLoginPageCb(QString::fromStdString(e.what())); return; } catch (const mtx::crypto::olm_exception &e) { nhlog::crypto()->critical("failed to create new olm account {}", e.what()); emit dropToLoginPageCb(QString::fromStdString(e.what())); return; } getProfileInfo(); tryInitialSync(); } void ChatPage::loadStateFromCache() { nhlog::db()->info("restoring state from cache"); try { olm::client()->load(cache::restoreOlmAccount(), STORAGE_SECRET_KEY); emit initializeEmptyViews(cache::client()->roomIds()); emit initializeRoomList(cache::roomInfo()); emit initializeMentions(cache::getTimelineMentions()); emit syncTags(cache::roomInfo().toStdMap()); cache::calculateRoomReadStatus(); } catch (const mtx::crypto::olm_exception &e) { nhlog::crypto()->critical("failed to restore olm account: {}", e.what()); emit dropToLoginPageCb(tr("Failed to restore OLM account. Please login again.")); return; } catch (const lmdb::error &e) { nhlog::db()->critical("failed to restore cache: {}", e.what()); emit dropToLoginPageCb(tr("Failed to restore save data. Please login again.")); return; } catch (const json::exception &e) { nhlog::db()->critical("failed to parse cache data: {}", e.what()); return; } nhlog::crypto()->info("ed25519 : {}", olm::client()->identity_keys().ed25519); nhlog::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519); getProfileInfo(); emit contentLoaded(); // Start receiving events. emit trySyncCb(); } void ChatPage::showQuickSwitcher() { auto dialog = new QuickSwitcher(this); connect(dialog, &QuickSwitcher::roomSelected, room_list_, &RoomList::highlightSelectedRoom); connect( dialog, &QuickSwitcher::closing, this, []() { MainWindow::instance()->hideOverlay(); }); MainWindow::instance()->showTransparentOverlayModal(dialog); } void ChatPage::removeRoom(const QString &room_id) { try { cache::removeRoom(room_id); cache::removeInvite(room_id.toStdString()); } catch (const lmdb::error &e) { nhlog::db()->critical("failure while removing room: {}", e.what()); // TODO: Notify the user. } room_list_->removeRoom(room_id, room_id == current_room_); } void ChatPage::removeLeftRooms(const std::map &rooms) { for (auto it = rooms.cbegin(); it != rooms.cend(); ++it) { const auto room_id = QString::fromStdString(it->first); room_list_->removeRoom(room_id, room_id == current_room_); } } void ChatPage::setGroupViewState(bool isEnabled) { if (!isEnabled) { communitiesList_->communityChanged("world"); communitiesList_->hide(); return; } communitiesList_->show(); } void ChatPage::updateRoomNotificationCount(const QString &room_id, uint16_t notification_count, uint16_t highlight_count) { room_list_->updateUnreadMessageCount(room_id, notification_count, highlight_count); } void ChatPage::sendNotifications(const mtx::responses::Notifications &res) { for (const auto &item : res.notifications) { const auto event_id = mtx::accessors::event_id(item.event); try { if (item.read) { cache::removeReadNotification(event_id); continue; } if (!cache::isNotificationSent(event_id)) { const auto room_id = QString::fromStdString(item.room_id); const auto user_id = QString::fromStdString(mtx::accessors::sender(item.event)); // We should only sent one notification per event. cache::markSentNotification(event_id); // Don't send a notification when the current room is opened. if (isRoomActive(room_id)) continue; if (userSettings_->hasAlertOnNotification()) { QApplication::alert(this); } if (userSettings_->hasDesktopNotifications()) { auto info = cache::singleRoomInfo(item.room_id); AvatarProvider::resolve( QString::fromStdString(info.avatar_url), 96, this, [this, room_id, event_id, item, user_id, info]( QPixmap image) { notificationsManager.postNotification( room_id, QString::fromStdString(event_id), QString::fromStdString(info.name), cache::displayName(room_id, user_id), utils::event_body(item.event), image.toImage()); }); } } } catch (const lmdb::error &e) { nhlog::db()->warn("error while sending notification: {}", e.what()); } } } void ChatPage::showNotificationsDialog(const QPoint &widgetPos) { auto notifDialog = user_mentions_popup_; notifDialog->setGeometry( widgetPos.x() - (width() / 10), widgetPos.y() + 25, width() / 5, height() / 2); notifDialog->raise(); notifDialog->showPopup(); } void ChatPage::tryInitialSync() { nhlog::crypto()->info("ed25519 : {}", olm::client()->identity_keys().ed25519); nhlog::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519); // Upload one time keys for the device. nhlog::crypto()->info("generating one time keys"); olm::client()->generate_one_time_keys(MAX_ONETIME_KEYS); http::client()->upload_keys( olm::client()->create_upload_keys_request(), [this](const mtx::responses::UploadKeys &res, mtx::http::RequestErr err) { if (err) { const int status_code = static_cast(err->status_code); if (status_code == 404) { nhlog::net()->warn( "skipping key uploading. server doesn't provide /keys/upload"); return startInitialSync(); } nhlog::crypto()->critical("failed to upload one time keys: {} {}", err->matrix_error.error, status_code); QString errorMsg(tr("Failed to setup encryption keys. Server response: " "%1 %2. Please try again later.") .arg(QString::fromStdString(err->matrix_error.error)) .arg(status_code)); emit dropToLoginPageCb(errorMsg); return; } olm::mark_keys_as_published(); for (const auto &entry : res.one_time_key_counts) nhlog::net()->info( "uploaded {} {} one-time keys", entry.second, entry.first); startInitialSync(); }); } void ChatPage::startInitialSync() { nhlog::net()->info("trying initial sync"); mtx::http::SyncOpts opts; opts.timeout = 0; opts.set_presence = currentPresence(); http::client()->sync( opts, [this](const mtx::responses::Sync &res, mtx::http::RequestErr err) { // TODO: Initial Sync should include mentions as well... if (err) { const auto error = QString::fromStdString(err->matrix_error.error); const auto msg = tr("Please try to login again: %1").arg(error); const auto err_code = mtx::errors::to_string(err->matrix_error.errcode); const int status_code = static_cast(err->status_code); nhlog::net()->error("initial sync error: {} {}", status_code, err_code); // non http related errors if (status_code <= 0 || status_code >= 600) { startInitialSync(); return; } switch (status_code) { case 502: case 504: case 524: { startInitialSync(); return; } default: { emit dropToLoginPageCb(msg); return; } } } nhlog::net()->info("initial sync completed"); try { cache::client()->saveState(res); olm::handle_to_device_messages(res.to_device.events); emit initializeViews(std::move(res.rooms)); emit initializeRoomList(cache::roomInfo()); emit initializeMentions(cache::getTimelineMentions()); cache::calculateRoomReadStatus(); emit syncTags(cache::roomInfo().toStdMap()); } catch (const lmdb::error &e) { nhlog::db()->error("failed to save state after initial sync: {}", e.what()); startInitialSync(); return; } emit trySyncCb(); emit contentLoaded(); }); } void ChatPage::handleSyncResponse(const mtx::responses::Sync &res) { nhlog::net()->debug("sync completed: {}", res.next_batch); // Ensure that we have enough one-time keys available. ensureOneTimeKeyCount(res.device_one_time_keys_count); // TODO: fine grained error handling try { cache::client()->saveState(res); olm::handle_to_device_messages(res.to_device.events); auto updates = cache::getRoomInfo(cache::client()->roomsWithStateUpdates(res)); emit syncRoomlist(updates); emit syncUI(res.rooms); emit syncTags(cache::getRoomInfo(cache::client()->roomsWithTagUpdates(res))); // if we process a lot of syncs (1 every 200ms), this means we clean the // db every 100s static int syncCounter = 0; if (syncCounter++ >= 500) { cache::deleteOldData(); syncCounter = 0; } } catch (const lmdb::map_full_error &e) { nhlog::db()->error("lmdb is full: {}", e.what()); cache::deleteOldData(); } catch (const lmdb::error &e) { nhlog::db()->error("saving sync response: {}", e.what()); } emit trySyncCb(); } void ChatPage::trySync() { mtx::http::SyncOpts opts; opts.set_presence = currentPresence(); if (!connectivityTimer_.isActive()) connectivityTimer_.start(); try { opts.since = cache::nextBatchToken(); } catch (const lmdb::error &e) { nhlog::db()->error("failed to retrieve next batch token: {}", e.what()); return; } http::client()->sync( opts, [this, since = cache::nextBatchToken()](const mtx::responses::Sync &res, mtx::http::RequestErr err) { if (since != cache::nextBatchToken()) { nhlog::net()->warn("Duplicate sync, dropping"); return; } if (err) { const auto error = QString::fromStdString(err->matrix_error.error); const auto msg = tr("Please try to login again: %1").arg(error); const auto err_code = mtx::errors::to_string(err->matrix_error.errcode); const int status_code = static_cast(err->status_code); if ((http::is_logged_in() && (err->matrix_error.errcode == mtx::errors::ErrorCode::M_UNKNOWN_TOKEN || err->matrix_error.errcode == mtx::errors::ErrorCode::M_MISSING_TOKEN)) || !http::is_logged_in()) { emit dropToLoginPageCb(msg); return; } nhlog::net()->error("sync error: {} {}", status_code, err_code); emit tryDelayedSyncCb(); return; } emit newSyncResponse(res); }); } void ChatPage::joinRoom(const QString &room) { const auto room_id = room.toStdString(); joinRoomVia(room_id, {}); } void ChatPage::joinRoomVia(const std::string &room_id, const std::vector &via) { http::client()->join_room( room_id, via, [this, room_id](const mtx::responses::RoomId &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to join room: %1") .arg(QString::fromStdString(err->matrix_error.error))); return; } emit tr("You joined the room"); // We remove any invites with the same room_id. try { cache::removeInvite(room_id); } catch (const lmdb::error &e) { emit showNotification(tr("Failed to remove invite: %1").arg(e.what())); } room_list_->highlightSelectedRoom(QString::fromStdString(room_id)); }); } void ChatPage::createRoom(const mtx::requests::CreateRoom &req) { http::client()->create_room( req, [this](const mtx::responses::CreateRoom &res, mtx::http::RequestErr err) { if (err) { const auto err_code = mtx::errors::to_string(err->matrix_error.errcode); const auto error = err->matrix_error.error; const int status_code = static_cast(err->status_code); nhlog::net()->warn( "failed to create room: {} {} ({})", error, err_code, status_code); emit showNotification( tr("Room creation failed: %1").arg(QString::fromStdString(error))); return; } emit showNotification( tr("Room %1 created.").arg(QString::fromStdString(res.room_id.to_string()))); }); } void ChatPage::leaveRoom(const QString &room_id) { http::client()->leave_room( room_id.toStdString(), [this, room_id](const mtx::responses::Empty &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to leave room: %1") .arg(QString::fromStdString(err->matrix_error.error))); return; } emit leftRoom(room_id); }); } void ChatPage::inviteUser(QString userid, QString reason) { auto room = current_room_; if (QMessageBox::question(this, tr("Confirm invite"), tr("Do you really want to invite %1 (%2)?") .arg(cache::displayName(current_room_, userid)) .arg(userid)) != QMessageBox::Yes) return; http::client()->invite_user( room.toStdString(), userid.toStdString(), [this, userid, room](const mtx::responses::Empty &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to invite %1 to %2: %3") .arg(userid) .arg(room) .arg(QString::fromStdString(err->matrix_error.error))); } else emit showNotification(tr("Invited user: %1").arg(userid)); }, reason.trimmed().toStdString()); } void ChatPage::kickUser(QString userid, QString reason) { auto room = current_room_; if (QMessageBox::question(this, tr("Confirm kick"), tr("Do you really want to kick %1 (%2)?") .arg(cache::displayName(current_room_, userid)) .arg(userid)) != QMessageBox::Yes) return; http::client()->kick_user( room.toStdString(), userid.toStdString(), [this, userid, room](const mtx::responses::Empty &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to kick %1 from %2: %3") .arg(userid) .arg(room) .arg(QString::fromStdString(err->matrix_error.error))); } else emit showNotification(tr("Kicked user: %1").arg(userid)); }, reason.trimmed().toStdString()); } void ChatPage::banUser(QString userid, QString reason) { auto room = current_room_; if (QMessageBox::question(this, tr("Confirm ban"), tr("Do you really want to ban %1 (%2)?") .arg(cache::displayName(current_room_, userid)) .arg(userid)) != QMessageBox::Yes) return; http::client()->ban_user( room.toStdString(), userid.toStdString(), [this, userid, room](const mtx::responses::Empty &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to ban %1 in %2: %3") .arg(userid) .arg(room) .arg(QString::fromStdString(err->matrix_error.error))); } else emit showNotification(tr("Banned user: %1").arg(userid)); }, reason.trimmed().toStdString()); } void ChatPage::unbanUser(QString userid, QString reason) { auto room = current_room_; if (QMessageBox::question(this, tr("Confirm unban"), tr("Do you really want to unban %1 (%2)?") .arg(cache::displayName(current_room_, userid)) .arg(userid)) != QMessageBox::Yes) return; http::client()->unban_user( room.toStdString(), userid.toStdString(), [this, userid, room](const mtx::responses::Empty &, mtx::http::RequestErr err) { if (err) { emit showNotification( tr("Failed to unban %1 in %2: %3") .arg(userid) .arg(room) .arg(QString::fromStdString(err->matrix_error.error))); } else emit showNotification(tr("Unbanned user: %1").arg(userid)); }, reason.trimmed().toStdString()); } void ChatPage::receivedSessionKey(const std::string &room_id, const std::string &session_id) { view_manager_->receivedSessionKey(room_id, session_id); } QString ChatPage::status() const { return QString::fromStdString(cache::statusMessage(utils::localUser().toStdString())); } void ChatPage::setStatus(const QString &status) { http::client()->put_presence_status( currentPresence(), status.toStdString(), [](mtx::http::RequestErr err) { if (err) { nhlog::net()->warn("failed to set presence status_msg: {}", err->matrix_error.error); } }); } mtx::presence::PresenceState ChatPage::currentPresence() const { switch (userSettings_->presence()) { case UserSettings::Presence::Online: return mtx::presence::online; case UserSettings::Presence::Unavailable: return mtx::presence::unavailable; case UserSettings::Presence::Offline: return mtx::presence::offline; default: return mtx::presence::online; } } void ChatPage::ensureOneTimeKeyCount(const std::map &counts) { for (const auto &entry : counts) { if (entry.second < MAX_ONETIME_KEYS) { const int nkeys = MAX_ONETIME_KEYS - entry.second; nhlog::crypto()->info("uploading {} {} keys", nkeys, entry.first); olm::client()->generate_one_time_keys(nkeys); http::client()->upload_keys( olm::client()->create_upload_keys_request(), [](const mtx::responses::UploadKeys &, mtx::http::RequestErr err) { if (err) { nhlog::crypto()->warn( "failed to update one-time keys: {} {}", err->matrix_error.error, static_cast(err->status_code)); return; } olm::mark_keys_as_published(); }); } } } void ChatPage::getProfileInfo() { const auto userid = utils::localUser().toStdString(); http::client()->get_profile( userid, [this](const mtx::responses::Profile &res, mtx::http::RequestErr err) { if (err) { nhlog::net()->warn("failed to retrieve own profile info"); return; } emit setUserDisplayName(QString::fromStdString(res.display_name)); emit setUserAvatar(QString::fromStdString(res.avatar_url)); }); http::client()->joined_groups( [this](const mtx::responses::JoinedGroups &res, mtx::http::RequestErr err) { if (err) { nhlog::net()->critical("failed to retrieve joined groups: {} {}", static_cast(err->status_code), err->matrix_error.error); return; } emit updateGroupsInfo(res); }); } void ChatPage::hideSideBars() { // Don't hide side bar, if we are currently only showing the side bar! if (view_manager_->getWidget()->isVisible()) { communitiesList_->hide(); sideBar_->hide(); } view_manager_->enableBackButton(); } void ChatPage::showSideBars() { if (userSettings_->groupView()) communitiesList_->show(); sideBar_->show(); view_manager_->disableBackButton(); content_->show(); } uint64_t ChatPage::timelineWidth() { int sidebarWidth = sideBar_->minimumSize().width(); sidebarWidth += communitiesList_->minimumSize().width(); nhlog::ui()->info("timelineWidth: {}", size().width() - sidebarWidth); return size().width() - sidebarWidth; } void ChatPage::initiateLogout() { http::client()->logout([this](const mtx::responses::Logout &, mtx::http::RequestErr err) { if (err) { // TODO: handle special errors emit contentLoaded(); nhlog::net()->warn("failed to logout: {} - {}", mtx::errors::to_string(err->matrix_error.errcode), err->matrix_error.error); return; } emit loggedOut(); }); emit showOverlayProgressBar(); } template void ChatPage::connectCallMessage() { connect(callManager_, qOverload(&CallManager::newMessage), view_manager_, qOverload(&TimelineViewManager::queueCallMessage)); } void ChatPage::decryptDownloadedSecrets(mtx::secret_storage::AesHmacSha2KeyDescription keyDesc, const SecretsToDecrypt &secrets) { QString text = QInputDialog::getText( ChatPage::instance(), QCoreApplication::translate("CrossSigningSecrets", "Decrypt secrets"), keyDesc.name.empty() ? QCoreApplication::translate( "CrossSigningSecrets", "Enter your recovery key or passphrase to decrypt your secrets:") : QCoreApplication::translate( "CrossSigningSecrets", "Enter your recovery key or passphrase called %1 to decrypt your secrets:") .arg(QString::fromStdString(keyDesc.name)), QLineEdit::Password); if (text.isEmpty()) return; auto decryptionKey = mtx::crypto::key_from_recoverykey(text.toStdString(), keyDesc); if (!decryptionKey) decryptionKey = mtx::crypto::key_from_passphrase(text.toStdString(), keyDesc); if (!decryptionKey) { QMessageBox::information( ChatPage::instance(), QCoreApplication::translate("CrossSigningSecrets", "Decryption failed"), QCoreApplication::translate("CrossSigningSecrets", "Failed to decrypt secrets with the " "provided recovery key or passphrase")); return; } for (const auto &[secretName, encryptedSecret] : secrets) { auto decrypted = mtx::crypto::decrypt(encryptedSecret, *decryptionKey, secretName); if (!decrypted.empty()) cache::storeSecret(secretName, decrypted); } } void ChatPage::startChat(QString userid) { auto joined_rooms = cache::joinedRooms(); auto room_infos = cache::getRoomInfo(joined_rooms); for (std::string room_id : joined_rooms) { if (room_infos[QString::fromStdString(room_id)].member_count == 2) { auto room_members = cache::roomMembers(room_id); if (std::find(room_members.begin(), room_members.end(), (userid).toStdString()) != room_members.end()) { room_list_->highlightSelectedRoom(QString::fromStdString(room_id)); return; } } } mtx::requests::CreateRoom req; req.preset = mtx::requests::Preset::PrivateChat; req.visibility = mtx::common::RoomVisibility::Private; if (utils::localUser() != userid) { req.invite = {userid.toStdString()}; req.is_direct = true; } emit ChatPage::instance()->createRoom(req); } static QString mxidFromSegments(QStringRef sigil, QStringRef mxid) { if (mxid.isEmpty()) return ""; auto mxid_ = QUrl::fromPercentEncoding(mxid.toUtf8()); if (sigil == "user") { return "@" + mxid_; } else if (sigil == "roomid") { return "!" + mxid_; } else if (sigil == "room") { return "#" + mxid_; } else if (sigil == "group") { return "+" + mxid_; } else { return ""; } } void ChatPage::handleMatrixUri(const QByteArray &uri) { nhlog::ui()->info("Received uri! {}", uri.toStdString()); QUrl uri_{QString::fromUtf8(uri)}; if (uri_.scheme() != "matrix") return; auto tempPath = uri_.path(QUrl::ComponentFormattingOption::FullyEncoded); if (tempPath.startsWith('/')) tempPath.remove(0, 1); auto segments = tempPath.splitRef('/'); if (segments.size() != 2 && segments.size() != 4) return; auto sigil1 = segments[0]; auto mxid1 = mxidFromSegments(sigil1, segments[1]); if (mxid1.isEmpty()) return; QString mxid2; if (segments.size() == 4 && segments[2] == "event") { if (segments[3].isEmpty()) return; else mxid2 = "$" + QUrl::fromPercentEncoding(segments[3].toUtf8()); } std::vector vias; QString action; for (QString item : uri_.query(QUrl::ComponentFormattingOption::FullyEncoded).split('&')) { nhlog::ui()->info("item: {}", item.toStdString()); if (item.startsWith("action=")) { action = item.remove("action="); } else if (item.startsWith("via=")) { vias.push_back( QUrl::fromPercentEncoding(item.remove("via=").toUtf8()).toStdString()); } } if (sigil1 == "user") { if (action.isEmpty()) { view_manager_->activeTimeline()->openUserProfile(mxid1); } else if (action == "chat") { this->startChat(mxid1); } } else if (sigil1 == "roomid") { auto joined_rooms = cache::joinedRooms(); auto targetRoomId = mxid1.toStdString(); for (auto roomid : joined_rooms) { if (roomid == targetRoomId) { room_list_->highlightSelectedRoom(mxid1); break; } } if (action == "join") { joinRoomVia(targetRoomId, vias); } } else if (sigil1 == "room") { auto joined_rooms = cache::joinedRooms(); auto targetRoomAlias = mxid1.toStdString(); for (auto roomid : joined_rooms) { auto aliases = cache::client()->getRoomAliases(roomid); if (aliases) { if (aliases->alias == targetRoomAlias) { room_list_->highlightSelectedRoom( QString::fromStdString(roomid)); break; } } } if (action == "join") { joinRoomVia(mxid1.toStdString(), vias); } } } void ChatPage::handleMatrixUri(const QUrl &uri) { handleMatrixUri(uri.toString(QUrl::ComponentFormattingOption::FullyEncoded).toUtf8()); }