2
0
mirror of https://github.com/telegramdesktop/tdesktop synced 2025-08-23 10:47:11 +00:00

329 lines
9.2 KiB
C
Raw Permalink Normal View History

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include <rpl/filter.h>
#include <rpl/variable.h>
#include "base/timer.h"
class ApiWrap;
namespace Api {
class Updates;
class SendProgressManager;
} // namespace Api
2019-11-13 11:31:12 +03:00
namespace MTP {
class Instance;
struct ConfigFields;
2019-11-13 11:31:12 +03:00
} // namespace MTP
namespace Support {
class Helper;
class Templates;
class FastButtonsBots;
} // namespace Support
2018-01-04 12:40:58 +03:00
namespace Data {
class Session;
class Changes;
2024-04-09 19:04:18 +04:00
class RecentPeers;
class RecentSharedMediaGifts;
class ScheduledMessages;
class SponsoredMessages;
2024-04-09 19:04:18 +04:00
class TopPeers;
2024-05-21 18:15:56 +04:00
class Factchecks;
2024-07-26 17:23:41 +02:00
class LocationPickers;
2024-08-06 12:48:06 +02:00
class Credits;
class PromoSuggestions;
2018-01-04 12:40:58 +03:00
} // namespace Data
namespace HistoryView::Reactions {
class CachedIconFactory;
} // namespace HistoryView::Reactions
namespace Storage {
class DownloadManagerMtproto;
class Uploader;
class Facade;
class Account;
class Domain;
} // namespace Storage
namespace Window {
class SessionController;
struct TermsLock;
} // namespace Window
2019-08-01 15:13:02 +01:00
namespace Stickers {
class EmojiPack;
class DicePacks;
class GiftBoxPack;
2019-08-01 15:13:02 +01:00
} // namespace Stickers;
namespace InlineBots {
class AttachWebView;
} // namespace InlineBots
namespace Ui {
struct ColorIndicesCompressed;
} // namespace Ui
2019-07-24 13:45:24 +02:00
namespace Main {
class Account;
2024-03-29 15:30:50 +04:00
class AppConfig;
class Domain;
class SessionSettings;
2021-11-09 16:10:51 +04:00
class SendAsPeers;
2019-07-24 13:45:24 +02:00
2025-03-10 17:52:13 +04:00
struct FreezeInfo {
TimeId since = 0;
TimeId until = 0;
QString appealUrl;
explicit operator bool() const {
return since != 0;
}
friend inline bool operator==(
const FreezeInfo &,
const FreezeInfo &) = default;
};
class Session final : public base::has_weak_ptr {
public:
Session(
not_null<Account*> account,
const MTPUser &user,
std::unique_ptr<SessionSettings> settings);
2019-07-24 13:45:24 +02:00
~Session();
2019-07-24 13:45:24 +02:00
Session(const Session &other) = delete;
Session &operator=(const Session &other) = delete;
[[nodiscard]] Account &account() const;
[[nodiscard]] Storage::Account &local() const;
[[nodiscard]] Domain &domain() const;
[[nodiscard]] Storage::Domain &domainLocal() const;
2024-03-29 15:30:50 +04:00
[[nodiscard]] AppConfig &appConfig() const;
2022-05-20 18:57:01 +04:00
[[nodiscard]] bool premium() const;
[[nodiscard]] bool premiumPossible() const;
[[nodiscard]] rpl::producer<bool> premiumPossibleValue() const;
[[nodiscard]] bool premiumBadgesShown() const;
[[nodiscard]] bool premiumCanBuy() const;
[[nodiscard]] bool isTestMode() const;
[[nodiscard]] uint64 uniqueId() const; // userId() with TestDC shift.
2019-08-23 16:52:59 +03:00
[[nodiscard]] UserId userId() const;
[[nodiscard]] PeerId userPeerId() const;
[[nodiscard]] not_null<UserData*> user() const {
return _user;
}
2021-11-19 23:04:40 +04:00
bool validateSelf(UserId id);
2021-10-12 16:50:18 +04:00
[[nodiscard]] Data::Changes &changes() const {
return *_changes;
}
2024-04-09 19:04:18 +04:00
[[nodiscard]] Data::RecentPeers &recentPeers() const {
return *_recentPeers;
}
[[nodiscard]] Data::RecentSharedMediaGifts &recentSharedGifts() const {
return *_recentSharedGifts;
}
[[nodiscard]] Data::SponsoredMessages &sponsoredMessages() const {
return *_sponsoredMessages;
}
[[nodiscard]] Data::ScheduledMessages &scheduledMessages() const {
return *_scheduledMessages;
}
2024-04-09 19:04:18 +04:00
[[nodiscard]] Data::TopPeers &topPeers() const {
return *_topPeers;
}
2024-07-25 18:08:22 +02:00
[[nodiscard]] Data::TopPeers &topBotApps() const {
return *_topBotApps;
}
2024-05-21 18:15:56 +04:00
[[nodiscard]] Data::Factchecks &factchecks() const {
return *_factchecks;
}
2024-07-26 17:23:41 +02:00
[[nodiscard]] Data::LocationPickers &locationPickers() const {
return *_locationPickers;
}
2024-08-06 12:48:06 +02:00
[[nodiscard]] Data::Credits &credits() const {
return *_credits;
}
[[nodiscard]] Api::Updates &updates() const {
return *_updates;
}
[[nodiscard]] Api::SendProgressManager &sendProgressManager() const {
return *_sendProgressManager;
}
[[nodiscard]] Storage::DownloadManagerMtproto &downloader() const {
return *_downloader;
}
[[nodiscard]] Storage::Uploader &uploader() const {
return *_uploader;
}
[[nodiscard]] Storage::Facade &storage() const {
return *_storage;
}
2020-03-04 13:21:19 +04:00
[[nodiscard]] Stickers::EmojiPack &emojiStickersPack() const {
2019-08-01 15:13:02 +01:00
return *_emojiStickersPack;
}
[[nodiscard]] Stickers::DicePacks &diceStickersPacks() const {
return *_diceStickersPacks;
2020-03-04 13:21:19 +04:00
}
[[nodiscard]] Stickers::GiftBoxPack &giftBoxStickersPacks() const {
return *_giftBoxStickersPacks;
}
[[nodiscard]] Data::Session &data() const {
return *_data;
}
[[nodiscard]] SessionSettings &settings() const {
return *_settings;
}
2021-11-09 16:10:51 +04:00
[[nodiscard]] SendAsPeers &sendAsPeers() const {
return *_sendAsPeers;
}
[[nodiscard]] InlineBots::AttachWebView &attachWebView() const {
return *_attachWebView;
}
[[nodiscard]] Data::PromoSuggestions &promoSuggestions() const {
return *_promoSuggestions;
}
[[nodiscard]] auto cachedReactionIconFactory() const
-> HistoryView::Reactions::CachedIconFactory & {
return *_cachedReactionIconFactory;
}
void saveSettings();
void saveSettingsDelayed(crl::time delay = kDefaultSaveDelay);
void saveSettingsNowIfNeeded();
void addWindow(not_null<Window::SessionController*> controller);
[[nodiscard]] auto windows() const
-> const base::flat_set<not_null<Window::SessionController*>> &;
2024-04-24 15:34:07 +04:00
[[nodiscard]] Window::SessionController *tryResolveWindow(
PeerData *forPeer = nullptr) const;
// Shortcuts.
void notifyDownloaderTaskFinished();
[[nodiscard]] rpl::producer<> downloaderTaskFinished() const;
[[nodiscard]] MTP::DcId mainDcId() const;
[[nodiscard]] MTP::Instance &mtp() const;
[[nodiscard]] const MTP::ConfigFields &serverConfig() const;
2019-08-23 16:52:59 +03:00
[[nodiscard]] ApiWrap &api() {
return *_api;
}
// Terms lock.
void lockByTerms(const Window::TermsLock &data);
void unlockTerms();
2019-03-27 12:37:25 +04:00
void termsDeleteNow();
[[nodiscard]] std::optional<Window::TermsLock> termsLocked() const;
rpl::producer<bool> termsLockChanges() const;
rpl::producer<bool> termsLockValue() const;
[[nodiscard]] QString createInternalLink(const QString &query) const;
[[nodiscard]] QString createInternalLinkFull(const QString &query) const;
[[nodiscard]] TextWithEntities createInternalLink(
const TextWithEntities &query) const;
[[nodiscard]] TextWithEntities createInternalLinkFull(
TextWithEntities query) const;
void setTmpPassword(const QByteArray &password, TimeId validUntil);
[[nodiscard]] QByteArray validTmpPassword() const;
2020-06-26 14:36:22 +04:00
// Can be called only right before ~Session.
void finishLogout();
// Uploads cancel with confirmation.
[[nodiscard]] bool uploadsInProgress() const;
void uploadsStopWithConfirmation(Fn<void()> done);
void uploadsStop();
2019-08-23 16:52:59 +03:00
[[nodiscard]] rpl::lifetime &lifetime() {
return _lifetime;
}
[[nodiscard]] bool supportMode() const;
[[nodiscard]] Support::Helper &supportHelper() const;
[[nodiscard]] Support::Templates &supportTemplates() const;
[[nodiscard]] Support::FastButtonsBots &fastButtonsBots() const;
2018-09-28 14:56:21 +03:00
2025-03-10 17:52:13 +04:00
[[nodiscard]] FreezeInfo frozen() const;
[[nodiscard]] rpl::producer<FreezeInfo> frozenValue() const;
2023-11-23 12:46:55 +04:00
[[nodiscard]] auto colorIndicesValue()
-> rpl::producer<Ui::ColorIndicesCompressed>;
private:
static constexpr auto kDefaultSaveDelay = crl::time(1000);
2025-03-10 17:52:13 +04:00
void appConfigRefreshed();
2024-02-23 21:23:15 +04:00
const UserId _userId;
const not_null<Account*> _account;
const std::unique_ptr<SessionSettings> _settings;
2021-10-12 16:50:18 +04:00
const std::unique_ptr<Data::Changes> _changes;
const std::unique_ptr<ApiWrap> _api;
const std::unique_ptr<Api::Updates> _updates;
const std::unique_ptr<Api::SendProgressManager> _sendProgressManager;
const std::unique_ptr<Storage::DownloadManagerMtproto> _downloader;
const std::unique_ptr<Storage::Uploader> _uploader;
const std::unique_ptr<Storage::Facade> _storage;
// _data depends on _downloader / _uploader.
const std::unique_ptr<Data::Session> _data;
2019-01-03 16:36:01 +04:00
const not_null<UserData*> _user;
2019-08-01 15:13:02 +01:00
// _emojiStickersPack depends on _data.
const std::unique_ptr<Stickers::EmojiPack> _emojiStickersPack;
const std::unique_ptr<Stickers::DicePacks> _diceStickersPacks;
const std::unique_ptr<Stickers::GiftBoxPack> _giftBoxStickersPacks;
2021-11-09 16:10:51 +04:00
const std::unique_ptr<SendAsPeers> _sendAsPeers;
const std::unique_ptr<InlineBots::AttachWebView> _attachWebView;
2024-04-09 19:04:18 +04:00
const std::unique_ptr<Data::RecentPeers> _recentPeers;
const std::unique_ptr<Data::RecentSharedMediaGifts> _recentSharedGifts;
const std::unique_ptr<Data::ScheduledMessages> _scheduledMessages;
const std::unique_ptr<Data::SponsoredMessages> _sponsoredMessages;
2024-04-09 19:04:18 +04:00
const std::unique_ptr<Data::TopPeers> _topPeers;
2024-07-25 18:08:22 +02:00
const std::unique_ptr<Data::TopPeers> _topBotApps;
2024-05-21 18:15:56 +04:00
const std::unique_ptr<Data::Factchecks> _factchecks;
2024-07-26 17:23:41 +02:00
const std::unique_ptr<Data::LocationPickers> _locationPickers;
2024-08-06 12:48:06 +02:00
const std::unique_ptr<Data::Credits> _credits;
const std::unique_ptr<Data::PromoSuggestions> _promoSuggestions;
2019-08-01 15:13:02 +01:00
using ReactionIconFactory = HistoryView::Reactions::CachedIconFactory;
const std::unique_ptr<ReactionIconFactory> _cachedReactionIconFactory;
const std::unique_ptr<Support::Helper> _supportHelper;
const std::unique_ptr<Support::FastButtonsBots> _fastButtonsBots;
std::shared_ptr<QImage> _selfUserpicView;
rpl::variable<bool> _premiumPossible = false;
2020-06-23 13:20:38 +04:00
rpl::event_stream<bool> _termsLockChanges;
std::unique_ptr<Window::TermsLock> _termsLock;
base::flat_set<not_null<Window::SessionController*>> _windows;
base::Timer _saveSettingsTimer;
2025-03-10 17:52:13 +04:00
rpl::variable<FreezeInfo> _frozen;
QByteArray _tmpPassword;
TimeId _tmpPasswordValidUntil = 0;
rpl::lifetime _lifetime;
};
2019-07-24 13:45:24 +02:00
} // namespace Main