tdesktop/Telegram/SourceFiles/window/notifications_manager.h

465 lines
11 KiB
C
Raw 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 "data/data_message_reaction_id.h"
2019-01-18 11:26:43 +00:00
#include "base/timer.h"
#include "base/type_traits.h"
2019-01-18 11:26:43 +00:00
class History;
2020-05-29 16:55:01 +00:00
namespace Data {
2022-04-07 07:34:29 +00:00
class Session;
class ForumTopic;
class Thread;
struct ItemNotification;
enum class ItemNotificationType;
2020-05-29 16:55:01 +00:00
} // namespace Data
namespace Ui {
struct PeerUserpicView;
} // namespace Ui
2019-07-24 11:45:24 +00:00
namespace Main {
class Session;
} // namespace Main
namespace Platform {
namespace Notifications {
class Manager;
} // namespace Notifications
} // namespace Platform
namespace Media::Audio {
class Track;
} // namespace Media::Audio
namespace Window {
2021-02-25 15:12:51 +00:00
class SessionController;
} // namespace Window
2021-02-25 15:12:51 +00:00
namespace Window::Notifications {
enum class ManagerType {
Dummy,
Default,
Native,
};
enum class ChangeType {
SoundEnabled,
FlashBounceEnabled,
IncludeMuted,
2018-12-04 10:32:06 +00:00
CountMessages,
DesktopEnabled,
ViewParams,
MaxCount,
Corner,
DemoIsShown,
DemoIsHidden,
};
} // namespace Window::Notifications
namespace base {
template <>
struct custom_is_fast_copy_type<Window::Notifications::ChangeType> : std::true_type {
};
} // namespace base
namespace base::options {
template <typename Type>
class option;
using toggle = option<bool>;
} // namespace base::options
namespace Window::Notifications {
extern const char kOptionGNotification[];
extern base::options::toggle OptionGNotification;
class Manager;
class System final {
public:
System();
~System();
[[nodiscard]] Main::Session *findSession(uint64 sessionId) const;
void createManager();
void setManager(std::unique_ptr<Manager> manager);
[[nodiscard]] Manager &manager() const;
void checkDelayed();
void schedule(Data::ItemNotification notification);
void clearFromTopic(not_null<Data::ForumTopic*> topic);
void clearFromHistory(not_null<History*> history);
void clearIncomingFromTopic(not_null<Data::ForumTopic*> topic);
void clearIncomingFromHistory(not_null<History*> history);
void clearFromSession(not_null<Main::Session*> session);
void clearFromItem(not_null<HistoryItem*> item);
void clearAll();
void clearAllFast();
void updateAll();
[[nodiscard]] rpl::producer<ChangeType> settingsChanged() const;
void notifySettingsChanged(ChangeType type);
2022-04-07 07:34:29 +00:00
void playSound(not_null<Main::Session*> session, DocumentId id);
[[nodiscard]] rpl::lifetime &lifetime() {
return _lifetime;
}
private:
struct Waiter;
struct SkipState {
enum Value {
Unknown,
Skip,
DontSkip
};
Value value = Value::Unknown;
bool silent = false;
};
struct NotificationInHistoryKey {
NotificationInHistoryKey(Data::ItemNotification notification);
NotificationInHistoryKey(
MsgId messageId,
Data::ItemNotificationType type);
MsgId messageId = 0;
Data::ItemNotificationType type = Data::ItemNotificationType();
friend inline auto operator<=>(
NotificationInHistoryKey a,
NotificationInHistoryKey b) = default;
};
struct Timing {
crl::time delay = 0;
crl::time when = 0;
};
struct ReactionNotificationId {
FullMsgId itemId;
uint64 sessionId = 0;
friend inline bool operator<(
ReactionNotificationId a,
ReactionNotificationId b) {
return std::pair(a.itemId, a.sessionId)
< std::pair(b.itemId, b.sessionId);
}
};
void clearForThreadIf(Fn<bool(not_null<Data::Thread*>)> predicate);
[[nodiscard]] SkipState skipNotification(
Data::ItemNotification notification) const;
[[nodiscard]] SkipState computeSkipState(
Data::ItemNotification notification) const;
[[nodiscard]] Timing countTiming(
not_null<Data::Thread*> thread,
crl::time minimalDelay) const;
[[nodiscard]] bool skipReactionNotification(
not_null<HistoryItem*> item) const;
void showNext();
void showGrouped();
void ensureSoundCreated();
2022-04-05 14:08:35 +00:00
[[nodiscard]] not_null<Media::Audio::Track*> lookupSound(
2022-04-07 07:34:29 +00:00
not_null<Data::Session*> owner,
2022-04-05 14:08:35 +00:00
DocumentId id);
void registerThread(not_null<Data::Thread*> thread);
base::flat_map<
not_null<Data::Thread*>,
base::flat_map<NotificationInHistoryKey, crl::time>> _whenMaps;
base::flat_map<not_null<Data::Thread*>, Waiter> _waiters;
base::flat_map<not_null<Data::Thread*>, Waiter> _settingWaiters;
2019-01-18 11:26:43 +00:00
base::Timer _waitTimer;
base::Timer _waitForAllGroupedTimer;
base::flat_map<
not_null<Data::Thread*>,
base::flat_map<crl::time, PeerData*>> _whenAlerts;
mutable base::flat_map<
ReactionNotificationId,
crl::time> _sentReactionNotifications;
std::unique_ptr<Manager> _manager;
rpl::event_stream<ChangeType> _settingsChanged;
std::unique_ptr<Media::Audio::Track> _soundTrack;
2022-04-05 14:08:35 +00:00
base::flat_map<
DocumentId,
std::unique_ptr<Media::Audio::Track>> _customSoundTracks;
base::flat_map<
not_null<Data::ForumTopic*>,
rpl::lifetime> _watchedTopics;
int _lastForwardedCount = 0;
uint64 _lastHistorySessionId = 0;
FullMsgId _lastHistoryItemId;
rpl::lifetime _lifetime;
};
class Manager {
public:
struct ContextId {
uint64 sessionId = 0;
PeerId peerId = 0;
MsgId topicRootId = 0;
friend inline auto operator<=>(
const ContextId&,
const ContextId&) = default;
[[nodiscard]] auto toAnyVector() const {
return std::vector<std::any>{
std::make_any<uint64>(sessionId),
std::make_any<uint64>(peerId.value),
std::make_any<int64>(topicRootId.bare),
};
}
[[nodiscard]] static auto FromAnyVector(const auto &vector) {
return ContextId{
std::any_cast<uint64>(vector[0]),
PeerIdHelper(std::any_cast<uint64>(vector[1])),
std::any_cast<int64>(vector[2]),
};
}
};
struct NotificationId {
ContextId contextId;
MsgId msgId = 0;
friend inline auto operator<=>(
const NotificationId&,
const NotificationId&) = default;
[[nodiscard]] auto toAnyVector() const {
return std::vector<std::any>{
std::make_any<std::vector<std::any>>(contextId.toAnyVector()),
std::make_any<int64>(msgId.bare),
};
}
[[nodiscard]] static auto FromAnyVector(const auto &vector) {
return NotificationId{
ContextId::FromAnyVector(
std::any_cast<std::vector<std::any>>(vector[0])),
std::any_cast<int64>(vector[1]),
};
}
};
struct NotificationFields {
not_null<HistoryItem*> item;
int forwardedCount = 0;
2022-01-28 15:47:04 +00:00
PeerData *reactionFrom = nullptr;
2022-08-16 11:28:17 +00:00
Data::ReactionId reactionId;
};
2019-07-24 11:13:51 +00:00
explicit Manager(not_null<System*> system) : _system(system) {
}
void showNotification(NotificationFields fields) {
doShowNotification(std::move(fields));
}
void updateAll() {
doUpdateAll();
}
void clearAll() {
doClearAll();
}
void clearAllFast() {
doClearAllFast();
}
void clearFromItem(not_null<HistoryItem*> item) {
doClearFromItem(item);
}
void clearFromTopic(not_null<Data::ForumTopic*> topic) {
doClearFromTopic(topic);
}
void clearFromHistory(not_null<History*> history) {
doClearFromHistory(history);
}
void clearFromSession(not_null<Main::Session*> session) {
doClearFromSession(session);
}
void notificationActivated(
NotificationId id,
const TextWithTags &draft = {});
void notificationReplied(NotificationId id, const TextWithTags &reply);
struct DisplayOptions {
bool hideNameAndPhoto = false;
bool hideMessageText = false;
bool hideMarkAsRead = false;
bool hideReplyButton = false;
bool spoilerLoginCode = false;
};
[[nodiscard]] DisplayOptions getNotificationOptions(
HistoryItem *item,
Data::ItemNotificationType type) const;
2022-08-29 06:10:15 +00:00
[[nodiscard]] static TextWithEntities ComposeReactionEmoji(
not_null<Main::Session*> session,
const Data::ReactionId &reaction);
[[nodiscard]] static TextWithEntities ComposeReactionNotification(
not_null<HistoryItem*> item,
2022-08-16 11:28:17 +00:00
const Data::ReactionId &reaction,
bool hideContent);
2022-11-01 16:57:36 +00:00
[[nodiscard]] TextWithEntities addTargetAccountName(
TextWithEntities title,
not_null<Main::Session*> session);
[[nodiscard]] QString addTargetAccountName(
const QString &title,
not_null<Main::Session*> session);
[[nodiscard]] virtual ManagerType type() const = 0;
[[nodiscard]] bool skipToast() const {
return doSkipToast();
}
2023-03-15 11:00:20 +00:00
void maybePlaySound(Fn<void()> playSound) {
doMaybePlaySound(std::move(playSound));
}
void maybeFlashBounce(Fn<void()> flashBounce) {
doMaybeFlashBounce(std::move(flashBounce));
}
virtual ~Manager() = default;
protected:
[[nodiscard]] not_null<System*> system() const {
return _system;
}
virtual void doUpdateAll() = 0;
virtual void doShowNotification(NotificationFields &&fields) = 0;
virtual void doClearAll() = 0;
virtual void doClearAllFast() = 0;
virtual void doClearFromItem(not_null<HistoryItem*> item) = 0;
virtual void doClearFromTopic(not_null<Data::ForumTopic*> topic) = 0;
virtual void doClearFromHistory(not_null<History*> history) = 0;
virtual void doClearFromSession(not_null<Main::Session*> session) = 0;
2023-03-15 11:00:20 +00:00
[[nodiscard]] virtual bool doSkipToast() const = 0;
virtual void doMaybePlaySound(Fn<void()> playSound) = 0;
virtual void doMaybeFlashBounce(Fn<void()> flashBounce) = 0;
[[nodiscard]] virtual bool forceHideDetails() const {
return false;
}
virtual void onBeforeNotificationActivated(NotificationId id) {
}
2021-02-25 15:12:51 +00:00
virtual void onAfterNotificationActivated(
NotificationId id,
not_null<SessionController*> window) {
}
[[nodiscard]] virtual QString accountNameSeparator();
private:
void openNotificationMessage(
not_null<History*> history,
MsgId messageId);
2019-07-24 11:13:51 +00:00
const not_null<System*> _system;
};
class NativeManager : public Manager {
public:
[[nodiscard]] ManagerType type() const override {
return ManagerType::Native;
}
protected:
using Manager::Manager;
void doUpdateAll() override {
doClearAllFast();
}
void doClearAll() override {
doClearAllFast();
}
void doShowNotification(NotificationFields &&fields) override;
bool forceHideDetails() const override;
virtual void doShowNativeNotification(
not_null<PeerData*> peer,
MsgId topicRootId,
Ui::PeerUserpicView &userpicView,
MsgId msgId,
const QString &title,
const QString &subtitle,
const QString &msg,
DisplayOptions options) = 0;
};
class DummyManager : public NativeManager {
public:
using NativeManager::NativeManager;
[[nodiscard]] ManagerType type() const override {
return ManagerType::Dummy;
}
protected:
void doShowNativeNotification(
not_null<PeerData*> peer,
MsgId topicRootId,
Ui::PeerUserpicView &userpicView,
MsgId msgId,
const QString &title,
const QString &subtitle,
const QString &msg,
DisplayOptions options) override {
}
void doClearAllFast() override {
}
void doClearFromItem(not_null<HistoryItem*> item) override {
}
void doClearFromTopic(not_null<Data::ForumTopic*> topic) override {
}
void doClearFromHistory(not_null<History*> history) override {
}
void doClearFromSession(not_null<Main::Session*> session) override {
}
2021-04-28 10:08:02 +00:00
bool doSkipToast() const override {
return false;
}
2023-03-15 11:00:20 +00:00
void doMaybePlaySound(Fn<void()> playSound) override {
playSound();
}
void doMaybeFlashBounce(Fn<void()> flashBounce) override {
flashBounce();
}
};
[[nodiscard]] QString WrapFromScheduled(const QString &text);
} // namespace Window::Notifications