init

Telegram/SourceFiles/data/data_message_reactions.h

@@ -0,0 +1,459 @@
+/*
+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 "base/timer.h"
+#include "data/data_message_reaction_id.h"
+#include "data/stickers/data_custom_emoji.h"
+
+namespace Calls {
+class GroupCall;
+} // namespace Calls
+
+namespace Ui {
+class AnimatedIcon;
+} // namespace Ui
+
+namespace Ui::Text {
+class CustomEmoji;
+} // namespace Ui::Text
+
+namespace Data {
+
+class SavedSublist;
+class DocumentMedia;
+class Session;
+
+struct Reaction {
+	ReactionId id;
+	QString title;
+	//not_null<DocumentData*> staticIcon;
+	not_null<DocumentData*> appearAnimation;
+	not_null<DocumentData*> selectAnimation;
+	//not_null<DocumentData*> activateAnimation;
+	//not_null<DocumentData*> activateEffects;
+	DocumentData *centerIcon = nullptr;
+	DocumentData *aroundAnimation = nullptr;
+	int count = 0;
+	bool active = false;
+	bool effect = false;
+	bool premium = false;
+};
+
+struct PossibleItemReactionsRef {
+	std::vector<not_null<const Reaction*>> recent;
+	std::vector<not_null<const Reaction*>> stickers;
+	bool customAllowed = false;
+	bool tags = false;
+};
+
+struct PossibleItemReactions {
+	PossibleItemReactions() = default;
+	explicit PossibleItemReactions(const PossibleItemReactionsRef &other);
+
+	std::vector<Reaction> recent;
+	std::vector<Reaction> stickers;
+	bool customAllowed = false;
+	bool tags = false;
+};
+
+[[nodiscard]] PossibleItemReactionsRef LookupPossibleReactions(
+	not_null<HistoryItem*> item,
+	bool paidInFront = false);
+[[nodiscard]] PossibleItemReactionsRef LookupPossibleReactions(
+	not_null<Main::Session*> session);
+
+struct MyTagInfo {
+	ReactionId id;
+	QString title;
+	int count = 0;
+};
+
+struct PaidReactionSend {
+	int count = 0;
+	bool valid = false;
+	std::optional<PeerId> shownPeer = PeerId();
+};
+
+class Reactions final : private CustomEmojiManager::Listener {
+public:
+	explicit Reactions(not_null<Session*> owner);
+	~Reactions();
+
+	[[nodiscard]] Session &owner() const {
+		return *_owner;
+	}
+	[[nodiscard]] Main::Session &session() const;
+
+	void refreshTop();
+	void refreshRecent();
+	void refreshRecentDelayed();
+	void refreshDefault();
+	void refreshMyTags(SavedSublist *sublist = nullptr);
+	void refreshMyTagsDelayed();
+	void refreshTags();
+	void refreshEffects();
+
+	enum class Type {
+		Active,
+		Recent,
+		Top,
+		All,
+		MyTags,
+		Tags,
+		Effects,
+	};
+	[[nodiscard]] const std::vector<Reaction> &list(Type type) const;
+	[[nodiscard]] const std::vector<MyTagInfo> &myTagsInfo() const;
+	[[nodiscard]] const QString &myTagTitle(const ReactionId &id) const;
+	[[nodiscard]] ReactionId favoriteId() const;
+	[[nodiscard]] const Reaction *favorite() const;
+	void setFavorite(const ReactionId &id);
+	void incrementMyTag(const ReactionId &id, SavedSublist *sublist);
+	void decrementMyTag(const ReactionId &id, SavedSublist *sublist);
+	void renameTag(const ReactionId &id, const QString &name);
+	[[nodiscard]] DocumentData *chooseGenericAnimation(
+		not_null<DocumentData*> custom) const;
+	[[nodiscard]] DocumentData *choosePaidReactionAnimation() const;
+
+	[[nodiscard]] rpl::producer<> topUpdates() const;
+	[[nodiscard]] rpl::producer<> recentUpdates() const;
+	[[nodiscard]] rpl::producer<> defaultUpdates() const;
+	[[nodiscard]] rpl::producer<> favoriteUpdates() const;
+	[[nodiscard]] rpl::producer<> myTagsUpdates() const;
+	[[nodiscard]] rpl::producer<> tagsUpdates() const;
+	[[nodiscard]] rpl::producer<ReactionId> myTagRenamed() const;
+	[[nodiscard]] rpl::producer<> effectsUpdates() const;
+
+	void preloadReactionImageFor(const ReactionId &emoji);
+	[[nodiscard]] QImage resolveReactionImageFor(const ReactionId &emoji);
+
+	// This is used to reserve space for the effect in BottomInfo but not
+	// actually paint anything, used in case we want to paint icon ourselves.
+	static constexpr auto kFakeEffectId = EffectId(1);
+
+	void preloadEffectImageFor(EffectId id);
+	[[nodiscard]] QImage resolveEffectImageFor(EffectId id);
+
+	void preloadAnimationsFor(const ReactionId &emoji);
+
+	void send(not_null<HistoryItem*> item, bool addToRecent);
+	[[nodiscard]] bool sending(not_null<HistoryItem*> item) const;
+
+	void poll(not_null<HistoryItem*> item, crl::time now);
+
+	void updateAllInHistory(not_null<PeerData*> peer, bool enabled);
+
+	void clearTemporary();
+	[[nodiscard]] Reaction *lookupTemporary(const ReactionId &id);
+	[[nodiscard]] not_null<Reaction*> lookupPaid();
+	[[nodiscard]] not_null<DocumentData*> paidToastAnimation();
+
+	[[nodiscard]] rpl::producer<std::vector<Reaction>> myTagsValue(
+		SavedSublist *sublist = nullptr);
+
+	[[nodiscard]] bool isQuitPrevent();
+
+	void schedulePaid(not_null<HistoryItem*> item);
+	void undoScheduledPaid(not_null<HistoryItem*> item);
+	[[nodiscard]] crl::time sendingScheduledPaidAt(
+		not_null<HistoryItem*> item) const;
+
+	void schedulePaid(not_null<Calls::GroupCall*> call);
+	void undoScheduledPaid(not_null<Calls::GroupCall*> call);
+	[[nodiscard]] crl::time sendingScheduledPaidAt(
+		not_null<Calls::GroupCall*> call) const;
+
+	[[nodiscard]] static crl::time ScheduledPaidDelay();
+
+	[[nodiscard]] static bool HasUnread(const MTPMessageReactions &data);
+	static void CheckUnknownForUnread(
+		not_null<Session*> owner,
+		const MTPMessage &message);
+
+private:
+	struct ImageSet {
+		QImage image;
+		std::shared_ptr<DocumentMedia> media;
+		std::unique_ptr<Ui::AnimatedIcon> icon;
+		bool fromSelectAnimation = false;
+		bool effect = false;
+	};
+	struct TagsBySublist {
+		TagsBySublist() = default;
+		TagsBySublist(TagsBySublist&&) = default;
+		TagsBySublist(const TagsBySublist&) = delete;
+		TagsBySublist &operator=(TagsBySublist&&) = default;
+		TagsBySublist &operator=(const TagsBySublist&) = delete;
+
+		std::vector<Reaction> tags;
+		std::vector<MyTagInfo> info;
+		uint64 hash = 0;
+		mtpRequestId requestId = 0;
+		bool requestScheduled = false;
+		bool updateScheduled = false;
+	};
+
+	[[nodiscard]] not_null<CustomEmojiManager::Listener*> resolveListener();
+	void customEmojiResolveDone(not_null<DocumentData*> document) override;
+
+	void requestTop();
+	void requestRecent();
+	void requestDefault();
+	void requestGeneric();
+	void requestMyTags(SavedSublist *sublist = nullptr);
+	void requestTags();
+	void requestEffects();
+
+	void updateTop(const MTPDmessages_reactions &data);
+	void updateRecent(const MTPDmessages_reactions &data);
+	void updateDefault(const MTPDmessages_availableReactions &data);
+	void updateGeneric(const MTPDmessages_stickerSet &data);
+	void updateMyTags(
+		SavedSublist *sublist,
+		const MTPDmessages_savedReactionTags &data);
+	void updateTags(const MTPDmessages_reactions &data);
+	void updateEffects(const MTPDmessages_availableEffects &data);
+
+	void recentUpdated();
+	void defaultUpdated();
+	void myTagsUpdated();
+	void tagsUpdated();
+	void effectsUpdated();
+
+	[[nodiscard]] std::optional<Reaction> resolveById(const ReactionId &id);
+	[[nodiscard]] std::vector<Reaction> resolveByIds(
+		const std::vector<ReactionId> &ids,
+		base::flat_set<ReactionId> &unresolved);
+	[[nodiscard]] std::optional<Reaction> resolveByInfo(
+		const MyTagInfo &info,
+		SavedSublist *sublist);
+	[[nodiscard]] std::vector<Reaction> resolveByInfos(
+		const std::vector<MyTagInfo> &infos,
+		base::flat_map<
+			ReactionId,
+			base::flat_set<SavedSublist*>> &unresolved,
+		SavedSublist *sublist);
+	void resolve(const ReactionId &id);
+	void applyFavorite(const ReactionId &id);
+	void scheduleMyTagsUpdate(SavedSublist *sublist);
+
+	[[nodiscard]] std::optional<Reaction> parse(
+		const MTPAvailableReaction &entry);
+	[[nodiscard]] std::optional<Reaction> parse(
+		const MTPAvailableEffect &entry);
+
+	void preloadEffect(const Reaction &effect);
+	void preloadImageFor(const ReactionId &id);
+	[[nodiscard]] QImage resolveImageFor(const ReactionId &id);
+	void loadImage(
+		ImageSet &set,
+		not_null<DocumentData*> document,
+		bool fromSelectAnimation);
+	void generateImage(ImageSet &set, const QString &emoji);
+	void setAnimatedIcon(ImageSet &set);
+	void resolveReactionImages();
+	void resolveEffectImages();
+	void downloadTaskFinished();
+
+	void fillPaidReactionAnimations() const;
+	[[nodiscard]] DocumentData *randomLoadedFrom(
+		std::vector<not_null<DocumentData*>> list) const;
+
+	void repaintCollected();
+	void pollCollected();
+
+	void sendPaid();
+	bool sendPaid(not_null<HistoryItem*> item);
+	void sendPaidRequest(
+		not_null<HistoryItem*> item,
+		PaidReactionSend send);
+	void sendPaidPrivacyRequest(
+		not_null<HistoryItem*> item,
+		PaidReactionSend send);
+	void sendPaidFinish(
+		not_null<HistoryItem*> item,
+		PaidReactionSend send,
+		bool success);
+	void checkQuitPreventFinished();
+
+	const not_null<Session*> _owner;
+
+	std::vector<Reaction> _active;
+	std::vector<Reaction> _available;
+	std::vector<Reaction> _recent;
+	std::vector<ReactionId> _recentIds;
+	base::flat_set<ReactionId> _unresolvedRecent;
+	base::flat_map<SavedSublist*, TagsBySublist> _myTags;
+	base::flat_map<
+		ReactionId,
+		base::flat_set<SavedSublist*>> _unresolvedMyTags;
+	std::vector<Reaction> _tags;
+	std::vector<ReactionId> _tagsIds;
+	base::flat_set<ReactionId> _unresolvedTags;
+	std::vector<Reaction> _top;
+	std::vector<ReactionId> _topIds;
+	base::flat_set<ReactionId> _unresolvedTop;
+	std::vector<not_null<DocumentData*>> _genericAnimations;
+	mutable std::vector<not_null<DocumentData*>> _paidReactionAnimations;
+	std::vector<Reaction> _effects;
+	ReactionId _favoriteId;
+	ReactionId _unresolvedFavoriteId;
+	std::optional<Reaction> _favorite;
+	base::flat_map<
+		not_null<DocumentData*>,
+		std::shared_ptr<DocumentMedia>> _iconsCache;
+	base::flat_map<
+		not_null<DocumentData*>,
+		std::shared_ptr<DocumentMedia>> _genericCache;
+	mutable base::flat_map<
+		not_null<DocumentData*>,
+		std::shared_ptr<DocumentMedia>> _paidReactionCache;
+	rpl::event_stream<> _topUpdated;
+	rpl::event_stream<> _recentUpdated;
+	rpl::event_stream<> _defaultUpdated;
+	rpl::event_stream<> _favoriteUpdated;
+	rpl::event_stream<SavedSublist*> _myTagsUpdated;
+	rpl::event_stream<> _tagsUpdated;
+	rpl::event_stream<ReactionId> _myTagRenamed;
+	rpl::event_stream<> _effectsUpdated;
+
+	// We need &i->second stay valid while inserting new items.
+	// So we use std::map instead of base::flat_map here.
+	// Otherwise we could use flat_map<DocumentId, unique_ptr<Reaction>>.
+	std::map<DocumentId, Reaction> _temporary;
+	std::optional<Reaction> _paid;
+	DocumentData *_paidToastAnimation = nullptr;
+
+	base::Timer _topRefreshTimer;
+	mtpRequestId _topRequestId = 0;
+	uint64 _topHash = 0;
+
+	mtpRequestId _recentRequestId = 0;
+	bool _recentRequestScheduled = false;
+	uint64 _recentHash = 0;
+
+	mtpRequestId _defaultRequestId = 0;
+	int32 _defaultHash = 0;
+
+	mtpRequestId _genericRequestId = 0;
+
+	mtpRequestId _tagsRequestId = 0;
+	uint64 _tagsHash = 0;
+
+	mtpRequestId _effectsRequestId = 0;
+	int32 _effectsHash = 0;
+
+	base::flat_map<ReactionId, ImageSet> _images;
+	rpl::lifetime _imagesLoadLifetime;
+	bool _waitingForReactions = false;
+	bool _waitingForEffects = false;
+
+	base::flat_map<FullMsgId, mtpRequestId> _sentRequests;
+
+	base::flat_map<not_null<HistoryItem*>, crl::time> _repaintItems;
+	base::Timer _repaintTimer;
+	base::flat_set<not_null<HistoryItem*>> _pollItems;
+	base::flat_set<not_null<HistoryItem*>> _pollingItems;
+	mtpRequestId _pollRequestId = 0;
+
+	base::flat_map<not_null<HistoryItem*>, crl::time> _sendPaidItems;
+	base::flat_map<not_null<HistoryItem*>, mtpRequestId> _sendingPaid;
+	base::Timer _sendPaidTimer;
+
+	base::flat_map<not_null<Calls::GroupCall*>, crl::time> _sendPaidCalls;
+
+	mtpRequestId _saveFaveRequestId = 0;
+
+	rpl::lifetime _lifetime;
+
+};
+
+struct RecentReaction {
+	not_null<PeerData*> peer;
+	bool unread = false;
+	bool big = false;
+	bool my = false;
+
+	friend inline bool operator==(
+		const RecentReaction &a,
+		const RecentReaction &b) = default;
+};
+
+struct MessageReactionsTopPaid {
+	PeerData *peer = nullptr;
+	uint32 count : 30 = 0;
+	uint32 top : 1 = 0;
+	uint32 my : 1 = 0;
+
+	friend inline bool operator==(
+		const MessageReactionsTopPaid &a,
+		const MessageReactionsTopPaid &b) = default;
+};
+
+class MessageReactions final {
+public:
+	explicit MessageReactions(not_null<HistoryItem*> item);
+	~MessageReactions();
+
+	using TopPaid = MessageReactionsTopPaid;
+
+	void add(const ReactionId &id, bool addToRecent);
+	void remove(const ReactionId &id);
+	bool change(
+		const QVector<MTPReactionCount> &list,
+		const QVector<MTPMessagePeerReaction> &recent,
+		const QVector<MTPMessageReactor> &top,
+		bool min);
+	[[nodiscard]] bool checkIfChanged(
+		const QVector<MTPReactionCount> &list,
+		const QVector<MTPMessagePeerReaction> &recent,
+		bool min) const;
+	[[nodiscard]] const std::vector<MessageReaction> &list() const;
+	[[nodiscard]] auto recent() const
+		-> const base::flat_map<ReactionId, std::vector<RecentReaction>> &;
+	[[nodiscard]] const std::vector<TopPaid> &topPaid() const;
+	[[nodiscard]] std::vector<ReactionId> chosen() const;
+	[[nodiscard]] bool empty() const;
+
+	[[nodiscard]] bool hasUnread() const;
+	void markRead();
+
+	void scheduleSendPaid(int count, std::optional<PeerId> shownPeer);
+	[[nodiscard]] int scheduledPaid() const;
+	void cancelScheduledPaid();
+
+	[[nodiscard]] PaidReactionSend startPaidSending();
+	void finishPaidSending(PaidReactionSend send, bool success);
+
+	[[nodiscard]] bool localPaidData() const;
+	[[nodiscard]] int localPaidCount() const;
+	[[nodiscard]] PeerId localPaidShownPeer() const;
+	bool clearCloudData();
+
+private:
+	struct Paid {
+		std::vector<TopPaid> top;
+		PeerId scheduledShownPeer = 0;
+		PeerId sendingShownPeer = 0;
+		uint32 scheduled: 30 = 0;
+		uint32 scheduledFlag : 1 = 0;
+		uint32 scheduledPrivacySet : 1 = 0;
+		uint32 sending : 30 = 0;
+		uint32 sendingFlag : 1 = 0;
+		uint32 sendingPrivacySet : 1 = 0;
+	};
+	const not_null<HistoryItem*> _item;
+
+	std::vector<MessageReaction> _list;
+	base::flat_map<ReactionId, std::vector<RecentReaction>> _recent;
+	std::unique_ptr<Paid> _paid;
+
+};
+
+} // namespace Data