// // Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024 // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #pragma once #include "td/telegram/AccessRights.h" #include "td/telegram/AffectedHistory.h" #include "td/telegram/BackgroundInfo.h" #include "td/telegram/ChannelId.h" #include "td/telegram/ChatReactions.h" #include "td/telegram/DialogDate.h" #include "td/telegram/DialogDb.h" #include "td/telegram/DialogFilterDialogInfo.h" #include "td/telegram/DialogFilterId.h" #include "td/telegram/DialogId.h" #include "td/telegram/DialogListId.h" #include "td/telegram/DialogNotificationSettings.h" #include "td/telegram/DialogParticipant.h" #include "td/telegram/DialogSource.h" #include "td/telegram/EncryptedFile.h" #include "td/telegram/files/FileId.h" #include "td/telegram/files/FileSourceId.h" #include "td/telegram/FolderId.h" #include "td/telegram/InputGroupCallId.h" #include "td/telegram/logevent/LogEventHelper.h" #include "td/telegram/MessageContentType.h" #include "td/telegram/MessageCopyOptions.h" #include "td/telegram/MessageDb.h" #include "td/telegram/MessageEffectId.h" #include "td/telegram/MessageFullId.h" #include "td/telegram/MessageId.h" #include "td/telegram/MessageInputReplyTo.h" #include "td/telegram/MessageLinkInfo.h" #include "td/telegram/MessageOrigin.h" #include "td/telegram/MessageReplyHeader.h" #include "td/telegram/MessageReplyInfo.h" #include "td/telegram/MessageSearchFilter.h" #include "td/telegram/MessageSelfDestructType.h" #include "td/telegram/MessagesInfo.h" #include "td/telegram/MessageSource.h" #include "td/telegram/MessageThreadInfo.h" #include "td/telegram/MessageTtl.h" #include "td/telegram/MessageViewer.h" #include "td/telegram/net/NetQuery.h" #include "td/telegram/Notification.h" #include "td/telegram/NotificationGroupFromDatabase.h" #include "td/telegram/NotificationGroupId.h" #include "td/telegram/NotificationGroupInfo.h" #include "td/telegram/NotificationGroupKey.h" #include "td/telegram/NotificationGroupType.h" #include "td/telegram/NotificationId.h" #include "td/telegram/NotificationSettingsScope.h" #include "td/telegram/OrderedMessage.h" #include "td/telegram/QuickReplyShortcutId.h" #include "td/telegram/ReactionType.h" #include "td/telegram/ReactionUnavailabilityReason.h" #include "td/telegram/RecentDialogList.h" #include "td/telegram/RepliedMessageInfo.h" #include "td/telegram/ReplyMarkup.h" #include "td/telegram/RestrictionReason.h" #include "td/telegram/SavedMessagesTopicId.h" #include "td/telegram/ScheduledServerMessageId.h" #include "td/telegram/secret_api.h" #include "td/telegram/SecretChatId.h" #include "td/telegram/SecretInputMedia.h" #include "td/telegram/ServerMessageId.h" #include "td/telegram/StoryFullId.h" #include "td/telegram/StoryNotificationSettings.h" #include "td/telegram/td_api.h" #include "td/telegram/telegram_api.h" #include "td/telegram/UserId.h" #include "td/actor/actor.h" #include "td/actor/MultiPromise.h" #include "td/actor/MultiTimeout.h" #include "td/actor/SignalSlot.h" #include "td/utils/buffer.h" #include "td/utils/ChangesProcessor.h" #include "td/utils/common.h" #include "td/utils/FlatHashMap.h" #include "td/utils/FlatHashSet.h" #include "td/utils/HashTableUtils.h" #include "td/utils/Heap.h" #include "td/utils/Hints.h" #include "td/utils/List.h" #include "td/utils/Promise.h" #include "td/utils/Slice.h" #include "td/utils/Status.h" #include "td/utils/StringBuilder.h" #include "td/utils/WaitFreeHashMap.h" #include "td/utils/WaitFreeHashSet.h" #include #include #include #include #include #include #include #include #include namespace td { struct BinlogEvent; class BusinessBotManageBar; class Dependencies; class DialogActionBar; class DialogFilter; class DraftMessage; class FactCheck; struct InputMessageContent; class MessageContent; class MessageForwardInfo; struct MessageReactions; struct MessageSearchOffset; class MissingInvitees; class Td; class Usernames; class MessagesManager final : public Actor { public: static constexpr int32 SEND_MESSAGE_FLAG_DISABLE_WEB_PAGE_PREVIEW = 1 << 1; static constexpr int32 SEND_MESSAGE_FLAG_HAS_REPLY_MARKUP = 1 << 2; static constexpr int32 SEND_MESSAGE_FLAG_HAS_ENTITIES = 1 << 3; // static constexpr int32 SEND_MESSAGE_FLAG_IS_POST = 1 << 4; static constexpr int32 SEND_MESSAGE_FLAG_DISABLE_NOTIFICATION = 1 << 5; static constexpr int32 SEND_MESSAGE_FLAG_FROM_BACKGROUND = 1 << 6; static constexpr int32 SEND_MESSAGE_FLAG_CLEAR_DRAFT = 1 << 7; static constexpr int32 SEND_MESSAGE_FLAG_WITH_MY_SCORE = 1 << 8; static constexpr int32 SEND_MESSAGE_FLAG_IS_FROM_THREAD = 1 << 9; static constexpr int32 SEND_MESSAGE_FLAG_HAS_SCHEDULE_DATE = 1 << 10; static constexpr int32 SEND_MESSAGE_FLAG_HAS_MESSAGE = 1 << 11; static constexpr int32 SEND_MESSAGE_FLAG_HAS_SEND_AS = 1 << 13; static constexpr int32 SEND_MESSAGE_FLAG_NOFORWARDS = 1 << 14; static constexpr int32 SEND_MESSAGE_FLAG_UPDATE_STICKER_SETS_ORDER = 1 << 15; static constexpr int32 SEND_MESSAGE_FLAG_INVERT_MEDIA = 1 << 16; static constexpr int32 SEND_MESSAGE_FLAG_EFFECT = 1 << 18; MessagesManager(Td *td, ActorShared<> parent); MessagesManager(const MessagesManager &) = delete; MessagesManager &operator=(const MessagesManager &) = delete; MessagesManager(MessagesManager &&) = delete; MessagesManager &operator=(MessagesManager &&) = delete; ~MessagesManager() final; static bool is_invalid_poll_message(const telegram_api::Message *message); static int32 get_message_date(const tl_object_ptr &message_ptr); void on_get_empty_messages(DialogId dialog_id, const vector &empty_message_ids); void get_channel_difference_if_needed(DialogId dialog_id, MessageId message_id, const char *source); void get_channel_difference_if_needed(DialogId dialog_id, MessagesInfo &&messages_info, Promise &&promise, const char *source); void get_channel_differences_if_needed(MessagesInfo &&messages_info, Promise &&promise, const char *source); void get_channel_differences_if_needed( const vector *> &messages, Promise &&promise, const char *source); void on_get_messages(vector> &&messages, bool is_channel_message, bool is_scheduled, Promise &&promise, const char *source); void on_get_history(DialogId dialog_id, MessageId from_message_id, MessageId old_last_new_message_id, int32 offset, int32 limit, bool from_the_end, vector> &&messages, Promise &&promise); void on_get_public_dialogs_search_result(const string &query, vector> &&my_peers, vector> &&peers); void on_failed_public_dialogs_search(const string &query, Status &&error); void on_get_message_search_result_calendar(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageId from_message_id, MessageSearchFilter filter, int32 total_count, vector> &&messages, vector> &&periods, Promise> &&promise); void on_get_call_messages(MessageId from_message_id, int32 limit, MessageSearchFilter filter, int32 total_count, vector> &&messages, Promise> &&promise); void on_get_dialog_messages_search_result(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, const string &query, DialogId sender_dialog_id, MessageId from_message_id, int32 offset, int32 limit, MessageSearchFilter filter, MessageId top_thread_message_id, const ReactionType &tag, int64 random_id, int32 total_count, vector> &&messages, Promise &&promise); void on_failed_dialog_messages_search(DialogId dialog_id, int64 random_id); void on_get_dialog_message_count(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageSearchFilter filter, int32 total_count, Promise &&promise); void on_get_messages_search_result(const string &query, int32 offset_date, DialogId offset_dialog_id, MessageId offset_message_id, int32 limit, MessageSearchFilter filter, int32 min_date, int32 max_date, int32 total_count, vector> &&messages, int32 next_rate, Promise> &&promise); void on_get_hashtag_search_result(const string &hashtag, const MessageSearchOffset &old_offset, int32 limit, int32 total_count, vector> &&messages, int32 next_rate, Promise> &&promise); void on_get_outgoing_document_messages(vector> &&messages, Promise> &&promise); void on_get_scheduled_server_messages(DialogId dialog_id, uint32 generation, vector> &&messages, bool is_not_modified); void on_get_recent_locations(DialogId dialog_id, int32 limit, int32 total_count, vector> &&messages, Promise> &&promise); MessageFullId on_get_message(tl_object_ptr message_ptr, bool from_update, bool is_channel_message, bool is_scheduled, const char *source); void open_secret_message(SecretChatId secret_chat_id, int64 random_id, Promise); void on_send_secret_message_success(int64 random_id, MessageId message_id, int32 date, unique_ptr file, Promise promise); void on_send_secret_message_error(int64 random_id, Status error, Promise promise); void delete_secret_messages(SecretChatId secret_chat_id, std::vector random_ids, Promise promise); void delete_secret_chat_history(SecretChatId secret_chat_id, bool remove_from_dialog_list, MessageId last_message_id, Promise promise); void read_secret_chat_outbox(SecretChatId secret_chat_id, int32 up_to_date, int32 read_date); void on_update_secret_chat_state(SecretChatId secret_chat_id, SecretChatState state); void on_get_secret_message(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, unique_ptr file, tl_object_ptr message, Promise promise); void on_secret_chat_screenshot_taken(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, int64 random_id, Promise promise); void on_secret_chat_ttl_changed(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, int32 ttl, int64 random_id, Promise promise); void on_update_sent_text_message(int64 random_id, tl_object_ptr message_media, vector> &&entities); void delete_pending_message_web_page(MessageFullId message_full_id); void on_get_dialogs(FolderId folder_id, vector> &&dialog_folders, int32 total_count, vector> &&messages, Promise &&promise); bool on_update_message_id(int64 random_id, MessageId new_message_id, const char *source); void on_update_dialog_draft_message(DialogId dialog_id, MessageId top_thread_message_id, tl_object_ptr &&draft_message, bool force = false); void on_update_dialog_is_pinned(FolderId folder_id, DialogId dialog_id, bool is_pinned); void on_update_pinned_dialogs(FolderId folder_id); void on_update_dialog_is_forum(DialogId dialog_id, bool is_forum); void on_update_dialog_view_as_messages(DialogId dialog_id, bool view_as_messages); void on_update_dialog_is_marked_as_unread(DialogId dialog_id, bool is_marked_as_unread); void on_update_dialog_is_translatable(DialogId dialog_id, bool is_translatable); void update_is_translatable(bool new_is_premium); void on_update_dialog_is_blocked(DialogId dialog_id, bool is_blocked, bool is_blocked_for_stories); void on_update_dialog_business_bot_is_paused(DialogId dialog_id, bool is_paused); void on_update_dialog_business_bot_removed(DialogId dialog_id); void on_update_dialog_last_pinned_message_id(DialogId dialog_id, MessageId last_pinned_message_id); void on_update_dialog_background(DialogId dialog_id, telegram_api::object_ptr &&wallpaper); void on_update_dialog_theme_name(DialogId dialog_id, string theme_name); void on_update_dialog_pending_join_requests(DialogId dialog_id, int32 pending_join_request_count, vector pending_requesters); void on_update_dialog_has_scheduled_server_messages(DialogId dialog_id, bool has_scheduled_server_messages); void on_update_dialog_folder_id(DialogId dialog_id, FolderId folder_id); void on_update_dialog_group_call(DialogId dialog_id, bool has_active_group_call, bool is_group_call_empty, const char *source, bool force = false); void on_update_dialog_group_call_id(DialogId dialog_id, InputGroupCallId input_group_call_id); void on_update_dialog_default_join_group_call_as_dialog_id(DialogId dialog_id, DialogId default_join_as_dialog_id, bool force); void on_update_dialog_default_send_message_as_dialog_id(DialogId dialog_id, DialogId default_send_as_dialog_id, bool force); void on_update_dialog_message_ttl(DialogId dialog_id, MessageTtl message_ttl); void on_update_service_notification(tl_object_ptr &&update, bool skip_new_entities, Promise &&promise); void on_update_read_channel_inbox(tl_object_ptr &&update); void on_update_read_channel_outbox(tl_object_ptr &&update); void on_update_read_channel_messages_contents( tl_object_ptr &&update); void on_update_read_message_comments(DialogId dialog_id, MessageId message_id, MessageId max_message_id, MessageId last_read_inbox_message_id, MessageId last_read_outbox_message_id, int32 unread_count); void on_update_channel_too_long(tl_object_ptr &&update, bool force_apply); void on_update_message_view_count(MessageFullId message_full_id, int32 view_count); void on_update_message_forward_count(MessageFullId message_full_id, int32 forward_count); void on_update_message_reactions(MessageFullId message_full_id, tl_object_ptr &&reactions, Promise &&promise); void update_message_reactions(MessageFullId message_full_id, unique_ptr &&reactions); void try_reload_message_reactions(DialogId dialog_id, bool is_finished); void on_get_message_reaction_list(MessageFullId message_full_id, const ReactionType &reaction_type, FlatHashMap, ReactionTypeHash> reaction_types, int32 total_count); void on_update_message_interaction_info(MessageFullId message_full_id, int32 view_count, int32 forward_count, bool has_reply_info, tl_object_ptr &&reply_info); void on_update_live_location_viewed(MessageFullId message_full_id); void on_update_some_live_location_viewed(Promise &&promise); void on_update_message_extended_media(MessageFullId message_full_id, telegram_api::object_ptr extended_media); void on_external_update_message_content(MessageFullId message_full_id, const char *source, bool expect_no_message = false); void on_update_message_content(MessageFullId message_full_id); void on_read_channel_inbox(ChannelId channel_id, MessageId max_message_id, int32 server_unread_count, int32 pts, const char *source); void on_read_channel_outbox(ChannelId channel_id, MessageId max_message_id); void on_update_channel_max_unavailable_message_id(ChannelId channel_id, MessageId max_unavailable_message_id, const char *source); void on_update_delete_scheduled_messages(DialogId dialog_id, vector &&server_message_ids); void on_dialog_speaking_action(DialogId dialog_id, DialogId speaking_dialog_id, int32 date); void on_message_animated_emoji_clicked(MessageFullId message_full_id, string &&emoji, string &&data); void read_history_inbox(DialogId dialog_id, MessageId max_message_id, int32 unread_count, const char *source); void delete_messages(DialogId dialog_id, const vector &message_ids, bool revoke, Promise &&promise); void on_failed_message_deletion(DialogId dialog_id, const vector &server_message_ids); void on_failed_scheduled_message_deletion(DialogId dialog_id, const vector &message_ids); void delete_dialog_history(DialogId dialog_id, bool remove_from_dialog_list, bool revoke, Promise &&promise); void delete_topic_history(DialogId dialog_id, MessageId top_thread_message_id, Promise &&promise); void delete_all_call_messages(bool revoke, Promise &&promise); void delete_dialog_messages_by_sender(DialogId dialog_id, DialogId sender_dialog_id, Promise &&promise); static Status fix_delete_message_min_max_dates(int32 &min_date, int32 &max_date); void delete_dialog_messages_by_date(DialogId dialog_id, int32 min_date, int32 max_date, bool revoke, Promise &&promise); void on_dialog_deleted(DialogId dialog_id, Promise &&promise); void on_update_dialog_group_call_rights(DialogId dialog_id); void read_all_dialog_mentions(DialogId dialog_id, MessageId top_thread_message_id, Promise &&promise); void read_all_dialog_reactions(DialogId dialog_id, MessageId top_thread_message_id, Promise &&promise); Status add_recently_found_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status remove_recently_found_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; void clear_recently_found_dialogs(); std::pair> search_recently_found_dialogs(const string &query, int32 limit, Promise &&promise); std::pair> get_recently_opened_dialogs(int32 limit, Promise &&promise); void get_dialog_send_message_as_dialog_ids(DialogId dialog_id, Promise> &&promise, bool is_recursive = false); void set_dialog_default_send_message_as_dialog_id(DialogId dialog_id, DialogId message_sender_dialog_id, Promise &&promise); bool get_dialog_silent_send_message(DialogId dialog_id) const; bool get_dialog_has_last_message(DialogId dialog_id) const; DialogId get_dialog_default_send_message_as_dialog_id(DialogId dialog_id) const; struct ForwardedMessageInfo { int32 origin_date_ = 0; MessageOrigin origin_; unique_ptr content_; }; ForwardedMessageInfo get_forwarded_message_info(MessageFullId message_full_id); MessageInputReplyTo create_message_input_reply_to(DialogId dialog_id, MessageId top_thread_message_id, td_api::object_ptr &&reply_to, bool for_draft); Result> send_message( DialogId dialog_id, const MessageId top_thread_message_id, td_api::object_ptr &&reply_to, tl_object_ptr &&options, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content) TD_WARN_UNUSED_RESULT; Result> send_message_group( DialogId dialog_id, const MessageId top_thread_message_id, td_api::object_ptr &&reply_to, tl_object_ptr &&options, vector> &&input_message_contents) TD_WARN_UNUSED_RESULT; Result send_bot_start_message(UserId bot_user_id, DialogId dialog_id, const string ¶meter) TD_WARN_UNUSED_RESULT; Result> send_inline_query_result_message( DialogId dialog_id, const MessageId top_thread_message_id, td_api::object_ptr &&reply_to, tl_object_ptr &&options, int64 query_id, const string &result_id, bool hide_via_bot) TD_WARN_UNUSED_RESULT; Result> forward_messages( DialogId to_dialog_id, MessageId top_thread_message_id, DialogId from_dialog_id, vector message_ids, tl_object_ptr &&options, bool in_game_share, vector &©_options) TD_WARN_UNUSED_RESULT; Result> send_quick_reply_shortcut_messages( DialogId dialog_id, QuickReplyShortcutId shortcut_id, int32 sending_id) TD_WARN_UNUSED_RESULT; Result> resend_messages(DialogId dialog_id, vector message_ids, td_api::object_ptr &"e) TD_WARN_UNUSED_RESULT; void set_dialog_message_ttl(DialogId dialog_id, int32 ttl, Promise &&promise); void share_dialogs_with_bot(MessageFullId message_full_id, int32 button_id, vector shared_dialog_ids, bool expect_user, bool only_check, Promise &&promise); Result add_local_message( DialogId dialog_id, td_api::object_ptr &&sender, td_api::object_ptr &&reply_to, bool disable_notification, tl_object_ptr &&input_message_content) TD_WARN_UNUSED_RESULT; void edit_message_text(MessageFullId message_full_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_message_live_location(MessageFullId message_full_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_location, int32 live_period, int32 heading, int32 proximity_alert_radius, Promise &&promise); void edit_message_media(MessageFullId message_full_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_message_caption(MessageFullId message_full_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_caption, bool invert_media, Promise &&promise); void edit_message_reply_markup(MessageFullId message_full_id, tl_object_ptr &&reply_markup, Promise &&promise); void edit_message_scheduling_state(MessageFullId message_full_id, td_api::object_ptr &&scheduling_state, Promise &&promise); void set_message_fact_check(MessageFullId message_full_id, td_api::object_ptr &&text, Promise &&promise); void get_dialog_filter_dialog_count(td_api::object_ptr filter, Promise &&promise); void add_dialog_list_for_dialog_filter(DialogFilterId dialog_filter_id); void edit_dialog_list_for_dialog_filter(unique_ptr &old_dialog_filter, unique_ptr new_dialog_filter, bool &disable_get_dialog_filter, const char *source); void delete_dialog_list_for_dialog_filter(DialogFilterId dialog_filter_id, const char *source); vector get_dialog_lists_to_add_dialog(DialogId dialog_id); void add_dialog_to_list(DialogId dialog_id, DialogListId dialog_list_id, Promise &&promise); void set_active_reactions(vector active_reaction_types); void set_dialog_available_reactions(DialogId dialog_id, td_api::object_ptr &&available_reactions_ptr, Promise &&promise); void set_dialog_theme(DialogId dialog_id, const string &theme_name, Promise &&promise); void pin_dialog_message(DialogId dialog_id, MessageId message_id, bool disable_notification, bool only_for_self, bool is_unpin, Promise &&promise); void unpin_all_dialog_messages(DialogId dialog_id, MessageId top_thread_message_id, Promise &&promise); bool have_dialog(DialogId dialog_id) const; bool have_dialog_force(DialogId dialog_id, const char *source); void reload_dialog_notification_settings(DialogId dialog_id, Promise &&promise, const char *source); bool load_dialog(DialogId dialog_id, int left_tries, Promise &&promise); void load_dialogs(vector dialog_ids, Promise> &&promise); Result get_dialog_list_last_date(DialogListId dialog_list_id); vector get_dialogs(DialogListId dialog_list_id, DialogDate offset, int32 limit, bool exact_limit, bool force, Promise &&promise); void get_dialogs_from_list(DialogListId dialog_list_id, int32 limit, Promise> &&promise); void read_all_dialogs_from_list(DialogListId dialog_list_id, Promise &&promise, bool is_recursive = false); vector search_public_dialogs(const string &query, Promise &&promise); std::pair> search_dialogs(const string &query, int32 limit, Promise &&promise); vector search_dialogs_on_server(const string &query, int32 limit, Promise &&promise); void block_message_sender_from_replies(MessageId message_id, bool need_delete_message, bool need_delete_all_messages, bool report_spam, Promise &&promise); bool is_dialog_blocked(DialogId dialog_id) const; void get_blocked_dialogs(const td_api::object_ptr &block_list, int32 offset, int32 limit, Promise> &&promise); void on_get_blocked_dialogs(int32 offset, int32 limit, int32 total_count, vector> &&blocked_peers, Promise> &&promise); bool can_get_message_statistics(MessageFullId message_full_id); DialogId get_dialog_message_sender(MessageFullId message_full_id); bool have_message_force(MessageFullId message_full_id, const char *source); void get_message(MessageFullId message_full_id, Promise &&promise); MessageFullId get_replied_message(DialogId dialog_id, MessageId message_id, bool force, Promise &&promise); MessageId get_dialog_pinned_message(DialogId dialog_id, Promise &&promise); void get_callback_query_message(DialogId dialog_id, MessageId message_id, int64 callback_query_id, Promise &&promise); bool get_messages(DialogId dialog_id, const vector &message_ids, Promise &&promise); void get_message_from_server(MessageFullId message_full_id, Promise &&promise, const char *source, tl_object_ptr input_message = nullptr); void get_messages_from_server(vector &&message_ids, Promise &&promise, const char *source, tl_object_ptr input_message = nullptr); void get_message_thread(DialogId dialog_id, MessageId message_id, Promise &&promise); td_api::object_ptr get_message_thread_info_object(const MessageThreadInfo &info); void process_discussion_message(telegram_api::object_ptr &&result, DialogId dialog_id, MessageId message_id, DialogId expected_dialog_id, MessageId expected_message_id, Promise promise); void get_message_read_date(MessageFullId message_full_id, Promise> &&promise); void get_message_viewers(MessageFullId message_full_id, Promise> &&promise); void translate_message_text(MessageFullId message_full_id, const string &to_language_code, Promise> &&promise); bool is_message_edited_recently(MessageFullId message_full_id, int32 seconds); struct ReportDialogFromActionBar { bool know_action_bar_ = false; bool is_reported_ = false; }; ReportDialogFromActionBar report_dialog_from_action_bar(DialogId dialog_id, Promise &promise); bool is_deleted_secret_chat(DialogId dialog_id) const; Result> get_message_link(MessageFullId message_full_id, int32 media_timestamp, bool for_group, bool in_message_thread); string get_message_embedding_code(MessageFullId message_full_id, bool for_group, Promise &&promise); void on_get_public_message_link(MessageFullId message_full_id, bool for_group, string url, string html); void get_message_link_info(Slice url, Promise &&promise); td_api::object_ptr get_message_link_info_object(const MessageLinkInfo &info) const; bool is_dialog_in_dialog_list(DialogId dialog_id) const; Status can_add_dialog_to_filter(DialogId dialog_id); Status delete_dialog_reply_markup(DialogId dialog_id, MessageId message_id) TD_WARN_UNUSED_RESULT; Status set_dialog_draft_message(DialogId dialog_id, MessageId top_thread_message_id, tl_object_ptr &&draft_message) TD_WARN_UNUSED_RESULT; void clear_all_draft_messages(bool exclude_secret_chats, Promise &&promise); Status toggle_dialog_is_pinned(DialogListId dialog_list_id, DialogId dialog_id, bool is_pinned) TD_WARN_UNUSED_RESULT; Status toggle_dialog_view_as_messages(DialogId dialog_id, bool view_as_messages) TD_WARN_UNUSED_RESULT; Status toggle_dialog_is_marked_as_unread(DialogId dialog_id, bool is_marked_as_unread) TD_WARN_UNUSED_RESULT; Status toggle_dialog_is_translatable(DialogId dialog_id, bool is_translatable) TD_WARN_UNUSED_RESULT; Status set_message_sender_block_list(const td_api::object_ptr &sender, const td_api::object_ptr &block_list) TD_WARN_UNUSED_RESULT; Status toggle_dialog_silent_send_message(DialogId dialog_id, bool silent_send_message) TD_WARN_UNUSED_RESULT; Status set_pinned_dialogs(DialogListId dialog_list_id, vector dialog_ids) TD_WARN_UNUSED_RESULT; Status set_dialog_client_data(DialogId dialog_id, string &&client_data) TD_WARN_UNUSED_RESULT; void create_dialog(DialogId dialog_id, bool force, Promise &&promise); bool is_dialog_opened(DialogId dialog_id) const; Status open_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status close_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status view_messages(DialogId dialog_id, vector message_ids, MessageSource source, bool force_read) TD_WARN_UNUSED_RESULT; void finish_get_message_views(DialogId dialog_id, const vector &message_ids); void finish_get_message_extended_media(DialogId dialog_id, const vector &message_ids); Status open_message_content(MessageFullId message_full_id) TD_WARN_UNUSED_RESULT; void click_animated_emoji_message(MessageFullId message_full_id, Promise> &&promise); StoryNotificationSettings get_story_notification_settings(DialogId dialog_id); vector get_dialog_notification_settings_exceptions(NotificationSettingsScope scope, bool filter_scope, bool compare_sound, bool force, Promise &&promise); Status set_dialog_notification_settings(DialogId dialog_id, tl_object_ptr &¬ification_settings) TD_WARN_UNUSED_RESULT; void reset_all_notification_settings(); void update_story_max_reply_media_timestamp_in_replied_messages(StoryFullId story_full_id); int64 get_chat_id_object(DialogId dialog_id, const char *source) const; td_api::object_ptr get_chat_object(DialogId dialog_id, const char *source); td_api::object_ptr get_my_dialog_draft_message_object() const; tl_object_ptr get_dialog_history(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, int left_tries, bool only_local, Promise &&promise); std::pair> get_message_thread_history(DialogId dialog_id, MessageId message_id, MessageId from_message_id, int32 offset, int32 limit, int64 &random_id, Promise &&promise); void get_dialog_message_calendar(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageId from_message_id, MessageSearchFilter filter, Promise> &&promise); struct FoundDialogMessages { vector message_ids; MessageId next_from_message_id; int32 total_count = 0; }; td_api::object_ptr get_found_chat_messages_object( DialogId dialog_id, const FoundDialogMessages &found_dialog_messages, const char *source); FoundDialogMessages search_dialog_messages(DialogId dialog_id, const string &query, const td_api::object_ptr &sender, MessageId from_message_id, int32 offset, int32 limit, MessageSearchFilter filter, MessageId top_thread_message_id, SavedMessagesTopicId saved_messages_topic_id, const ReactionType &tag, int64 &random_id, bool use_db, Promise &&promise); struct FoundMessages { vector message_full_ids; string next_offset; int32 total_count = 0; }; td_api::object_ptr get_found_messages_object(const FoundMessages &found_messages, const char *source); void offline_search_messages(DialogId dialog_id, const string &query, string offset, int32 limit, MessageSearchFilter filter, Promise> &&promise); void search_messages(DialogListId dialog_list_id, bool ignore_folder_id, bool broadcasts_only, const string &query, const string &offset_str, int32 limit, MessageSearchFilter filter, int32 min_date, int32 max_date, Promise> &&promise); void search_call_messages(const string &offset, int32 limit, bool only_missed, Promise> &&promise); void search_outgoing_document_messages(const string &query, int32 limit, Promise> &&promise); void search_hashtag_posts(string hashtag, string offset_str, int32 limit, Promise> &&promise); void search_dialog_recent_location_messages(DialogId dialog_id, int32 limit, Promise> &&promise); vector get_active_live_location_messages(Promise &&promise); void get_dialog_message_by_date(DialogId dialog_id, int32 date, Promise> &&promise); void on_get_dialog_message_by_date(DialogId dialog_id, int32 date, vector> &&messages, Promise> &&promise); void get_dialog_sparse_message_positions(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageSearchFilter filter, MessageId from_message_id, int32 limit, Promise> &&promise); static void on_get_dialog_sparse_message_positions( DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageSearchFilter filter, telegram_api::object_ptr positions, Promise> &&promise); void get_dialog_message_count(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageSearchFilter filter, bool return_local, Promise &&promise); void get_dialog_message_position(MessageFullId message_full_id, MessageSearchFilter filter, MessageId top_thread_message_id, SavedMessagesTopicId saved_messages_topic_id, Promise &&promise); vector get_dialog_scheduled_messages(DialogId dialog_id, bool force, bool ignore_result, Promise &&promise); using AffectedHistoryQuery = std::function)>; void run_affected_history_query_until_complete(DialogId dialog_id, AffectedHistoryQuery query, bool get_affected_messages, Promise &&promise); Result> get_message_available_reactions(MessageFullId message_full_id, int32 row_size); void add_message_reaction(MessageFullId message_full_id, ReactionType reaction_type, bool is_big, bool add_to_recent, Promise &&promise); void remove_message_reaction(MessageFullId message_full_id, ReactionType reaction_type, Promise &&promise); td_api::object_ptr get_dialog_event_log_message_object( DialogId dialog_id, tl_object_ptr &&message, DialogId &sender_dialog_id); td_api::object_ptr get_business_message_object( telegram_api::object_ptr &&message, telegram_api::object_ptr &&reply_to_message); td_api::object_ptr get_message_object(MessageFullId message_full_id, const char *source); td_api::object_ptr get_messages_object(int32 total_count, DialogId dialog_id, const vector &message_ids, bool skip_not_found, const char *source); td_api::object_ptr get_messages_object(int32 total_count, const vector &message_full_ids, bool skip_not_found, const char *source); void process_pts_update(tl_object_ptr &&update_ptr); void skip_old_pending_pts_update(tl_object_ptr &&update, int32 new_pts, int32 old_pts, int32 pts_count, const char *source); void add_pending_channel_update(DialogId dialog_id, tl_object_ptr &&update, int32 new_pts, int32 pts_count, Promise &&promise, const char *source, bool is_postponed_update = false); bool is_old_channel_update(DialogId dialog_id, int32 new_pts); void on_dialog_bots_updated(DialogId dialog_id, vector bot_user_ids, bool from_database); void on_dialog_photo_updated(DialogId dialog_id); void on_dialog_accent_colors_updated(DialogId dialog_id); void on_dialog_title_updated(DialogId dialog_id); void on_dialog_emoji_status_updated(DialogId dialog_id); void on_dialog_usernames_updated(DialogId dialog_id, const Usernames &old_usernames, const Usernames &new_usernames); void on_dialog_default_permissions_updated(DialogId dialog_id); void on_dialog_has_protected_content_updated(DialogId dialog_id); void on_dialog_user_is_contact_updated(DialogId dialog_id, bool is_contact); void on_dialog_user_is_deleted_updated(DialogId dialog_id, bool is_deleted); void on_dialog_linked_channel_updated(DialogId dialog_id, ChannelId old_linked_channel_id, ChannelId new_linked_channel_id) const; void drop_dialog_pending_join_requests(DialogId dialog_id); void on_update_notification_scope_is_muted(NotificationSettingsScope scope, bool is_muted); void on_update_dialog_notify_settings(DialogId dialog_id, tl_object_ptr &&peer_notify_settings, const char *source); void on_update_dialog_available_reactions(DialogId dialog_id, telegram_api::object_ptr &&available_reactions, int32 reactions_limit); void hide_dialog_action_bar(DialogId dialog_id); void remove_dialog_action_bar(DialogId dialog_id, Promise &&promise); void reget_dialog_action_bar(DialogId dialog_id, const char *source, bool is_repair = true); void hide_all_business_bot_manager_bars(); void on_get_peer_settings(DialogId dialog_id, tl_object_ptr &&peer_settings, bool ignore_privacy_exception = false); void on_authorization_success(); void before_get_difference(); void after_get_difference(); bool on_get_message_error(DialogId dialog_id, MessageId message_id, const Status &status, const char *source); void on_send_message_get_quick_ack(int64 random_id); void check_send_message_result(int64 random_id, DialogId dialog_id, const telegram_api::Updates *updates_ptr, const char *source); MessageFullId on_send_message_success(int64 random_id, MessageId new_message_id, int32 date, int32 ttl_period, FileId new_file_id, const char *source); void on_send_message_file_parts_missing(int64 random_id, vector &&bad_parts); void on_send_message_file_reference_error(int64 random_id); void on_send_media_group_file_reference_error(DialogId dialog_id, vector random_ids); void on_send_message_fail(int64 random_id, Status error); void on_upload_message_media_success(DialogId dialog_id, MessageId message_id, tl_object_ptr &&media); void on_upload_message_media_file_parts_missing(DialogId dialog_id, MessageId message_id, vector &&bad_parts); void on_upload_message_media_fail(DialogId dialog_id, MessageId message_id, Status error); void on_create_new_dialog(telegram_api::object_ptr &&updates, MissingInvitees &&missing_invitees, Promise> &&chat_promise, Promise> &&channel_promise); void on_get_channel_difference(DialogId dialog_id, int32 request_pts, int32 request_limit, tl_object_ptr &&difference_ptr, Status &&status); void try_update_dialog_pos(DialogId dialog_id); void force_create_dialog(DialogId dialog_id, const char *source, bool expect_no_access = false, bool force_update_dialog_pos = false); void on_get_dialog_query_finished(DialogId dialog_id, Status &&status); void remove_sponsored_dialog(); void on_get_sponsored_dialog(tl_object_ptr peer, DialogSource source, vector> users, vector> chats); FileSourceId get_message_file_source_id(MessageFullId message_full_id, bool force = false); struct MessagePushNotificationInfo { NotificationGroupId group_id; NotificationGroupType group_type = NotificationGroupType::Calls; DialogId settings_dialog_id; }; Result get_message_push_notification_info(DialogId dialog_id, MessageId message_id, int64 random_id, UserId sender_user_id, DialogId sender_dialog_id, int32 date, bool is_from_scheduled, bool contains_mention, bool is_pinned, bool is_from_binlog); NotificationGroupFromDatabase get_message_notification_group_force(NotificationGroupId group_id); vector get_message_notification_group_keys_from_database(NotificationGroupKey from_group_key, int32 limit); void get_message_notifications_from_database(DialogId dialog_id, NotificationGroupId group_id, NotificationId from_notification_id, MessageId from_message_id, int32 limit, Promise> promise); void remove_message_notification(DialogId dialog_id, NotificationGroupId group_id, NotificationId notification_id); void remove_message_notifications_by_message_ids(DialogId dialog_id, const vector &message_ids); void remove_message_notifications(DialogId dialog_id, NotificationGroupId group_id, NotificationId max_notification_id, MessageId max_message_id); void remove_scope_pinned_message_notifications(NotificationSettingsScope scope); void on_update_scope_mention_notifications(NotificationSettingsScope scope, bool disable_mention_notifications); void on_binlog_events(vector &&events); void set_poll_answer(MessageFullId message_full_id, vector &&option_ids, Promise &&promise); void get_poll_voters(MessageFullId message_full_id, int32 option_id, int32 offset, int32 limit, Promise> &&promise); void stop_poll(MessageFullId message_full_id, td_api::object_ptr &&reply_markup, Promise &&promise); Result get_login_button_url(MessageFullId message_full_id, int64 button_id); Result get_invoice_message_id(MessageFullId message_full_id); Result get_payment_successful_message_id(MessageFullId message_full_id); Result get_giveaway_message_id(MessageFullId message_full_id); bool can_set_game_score(MessageFullId message_full_id) const; void get_current_state(vector> &updates) const; void add_message_file_to_downloads(MessageFullId message_full_id, FileId file_id, int32 priority, Promise> promise); void get_message_file_search_text(MessageFullId message_full_id, string unique_file_id, Promise promise); private: class PendingPtsUpdate { public: tl_object_ptr update; int32 pts; int32 pts_count; Promise promise; PendingPtsUpdate(tl_object_ptr &&update, int32 pts, int32 pts_count, Promise &&promise) : update(std::move(update)), pts(pts), pts_count(pts_count), promise(std::move(promise)) { } }; struct MessageInfo { DialogId dialog_id; MessageId message_id; UserId sender_user_id; DialogId sender_dialog_id; SavedMessagesTopicId saved_messages_topic_id; int32 date = 0; int32 ttl_period = 0; MessageSelfDestructType ttl; bool disable_web_page_preview = false; int64 random_id = 0; tl_object_ptr forward_header; MessageReplyHeader reply_header; UserId via_bot_user_id; UserId via_business_bot_user_id; int32 view_count = 0; int32 forward_count = 0; tl_object_ptr reply_info; tl_object_ptr reactions; tl_object_ptr fact_check; int32 sender_boost_count = 0; int32 edit_date = 0; vector restriction_reasons; string author_signature; int64 media_album_id = 0; MessageEffectId effect_id; bool is_outgoing = false; bool is_silent = false; bool is_channel_post = false; bool is_legacy = false; bool hide_edit_date = false; bool is_from_scheduled = false; bool is_from_offline = false; bool is_pinned = false; bool noforwards = false; bool has_mention = false; bool has_unread_content = false; bool invert_media = false; unique_ptr content; tl_object_ptr reply_markup; }; // Do not forget to update MessagesManager::update_message and all make_unique when this class is changed struct Message final : public ListNode { MessageId message_id; UserId sender_user_id; DialogId sender_dialog_id; SavedMessagesTopicId saved_messages_topic_id; int32 date = 0; int32 edit_date = 0; int32 send_date = 0; int32 sending_id = 0; // for yet unsent messages int32 sender_boost_count = 0; int64 random_id = 0; unique_ptr forward_info; RepliedMessageInfo replied_message_info; StoryFullId reply_to_story_full_id; MessageId top_thread_message_id; MessageId linked_top_thread_message_id; vector local_thread_message_ids; MessageId initial_top_thread_message_id; // for send_message MessageInputReplyTo input_reply_to; // for send_message int64 reply_to_random_id = 0; // for send_message string send_emoji; // for send_message UserId via_bot_user_id; UserId via_business_bot_user_id; vector restriction_reasons; string author_signature; bool is_channel_post = false; bool is_topic_message = false; bool is_outgoing = false; bool is_failed_to_send = false; bool disable_notification = false; bool contains_mention = false; bool contains_unread_mention = false; bool hide_edit_date = false; bool had_reply_markup = false; // had non-inline reply markup? bool had_forward_info = false; bool is_content_secret = false; // must be shown only while tapped bool is_mention_notification_disabled = false; bool is_from_scheduled = false; bool is_from_offline = false; bool is_pinned = false; bool are_media_timestamp_entities_found = false; bool noforwards = false; bool invert_media = false; bool disable_web_page_preview = false; bool has_explicit_sender = false; // for send_message bool is_copy = false; // for send_message bool from_background = false; // for send_message bool update_stickersets_order = false; // for send_message bool clear_draft = false; // for send_message bool in_game_share = false; // for send_message bool hide_via_bot = false; // for resend_message bool is_bot_start_message = false; // for resend_message bool has_get_message_views_query = false; bool need_view_counter_increment = false; bool has_get_extended_media_query = false; DialogId real_forward_from_dialog_id; // for resend_message MessageId real_forward_from_message_id; // for resend_message NotificationId notification_id; NotificationId removed_notification_id; int32 max_reply_media_timestamp = -1; int32 max_own_media_timestamp = -2; // to update replied messages on the first load int32 view_count = 0; int32 forward_count = 0; MessageReplyInfo reply_info; unique_ptr reactions; unique_ptr fact_check; unique_ptr thread_draft_message; uint32 available_reactions_generation = 0; int32 interaction_info_update_date = 0; uint32 history_generation = 0; int32 legacy_layer = 0; int32 send_error_code = 0; string send_error_message; double try_resend_at = 0; int32 ttl_period = 0; // counted from message send date MessageSelfDestructType ttl; // counted from message content view date double ttl_expires_at = 0; // only for TTL int64 media_album_id = 0; MessageEffectId effect_id; unique_ptr content; unique_ptr reply_markup; int32 edited_schedule_date = 0; bool edited_invert_media = false; unique_ptr edited_content; unique_ptr edited_reply_markup; uint64 edit_generation = 0; Promise edit_promise; int32 last_edit_pts = 0; const char *debug_source = "null"; mutable int32 last_access_date = 0; mutable bool is_update_sent = false; // whether the message is known to the app mutable uint64 send_message_log_event_id = 0; mutable NetQueryRef send_query_ref; template void store(StorerT &storer) const; template void parse(ParserT &parser); Message() = default; Message(const Message &) = delete; Message &operator=(const Message &) = delete; Message(Message &&) = delete; Message &operator=(Message &&) = delete; ~Message() = default; }; struct DialogScheduledMessages { FlatHashMap scheduled_message_date_; FlatHashMap last_assigned_scheduled_message_id_; // date -> message_id FlatHashSet deleted_scheduled_server_message_ids_; FlatHashMap, MessageIdHash> scheduled_messages_; }; struct NotificationInfo { NotificationGroupInfo message_notification_group_; NotificationGroupInfo mention_notification_group_; NotificationId new_secret_chat_notification_id_; // secret chats only MessageId pinned_message_notification_message_id_; MessageId max_push_notification_message_id_; vector> pending_new_message_notifications_; vector> pending_new_mention_notifications_; FlatHashMap notification_id_to_message_id_; }; struct Dialog { DialogId dialog_id; MessageId last_new_message_id; // identifier of the last known server message received from update, there should be // no server messages after it MessageId last_message_id; // identifier of the message after which currently there are no messages, i.e. a // message without a gap after it, memory only MessageId first_database_message_id; // identifier of the first message in the database, needed // until there are no gaps in the database MessageId last_database_message_id; // identifier of the last local or server message, if last_database_message_id // is known and last_message_id is known, then last_database_message_id <= // last_message_id std::array first_database_message_id_by_index; // use struct Count? std::array message_count_by_index{{0}}; int32 server_unread_count = 0; int32 local_unread_count = 0; int32 unread_mention_count = 0; int32 unread_reaction_count = 0; int32 last_read_inbox_message_date = 0; // secret chats only MessageId last_read_inbox_message_id; MessageId last_read_outbox_message_id; MessageId last_pinned_message_id; MessageId reply_markup_message_id; DialogNotificationSettings notification_settings; ChatReactions available_reactions; uint32 available_reactions_generation = 0; MessageTtl message_ttl; unique_ptr draft_message; unique_ptr action_bar; unique_ptr business_bot_manage_bar; LogEventIdWithGeneration save_draft_message_log_event_id; LogEventIdWithGeneration save_notification_settings_log_event_id; LogEventIdWithGeneration set_folder_id_log_event_id; InputGroupCallId active_group_call_id; InputGroupCallId expected_active_group_call_id; DialogId default_join_group_call_as_dialog_id; DialogId default_send_message_as_dialog_id; BackgroundInfo background_info; string theme_name; int32 pending_join_request_count = 0; vector pending_join_request_user_ids; int32 have_full_history_source = 0; int32 unload_dialog_delay_seed = 0; int64 last_media_album_id = 0; uint32 history_generation = 0; uint32 open_count = 0; unique_ptr notification_info; FolderId folder_id; vector dialog_list_ids; // TODO replace with mask MessageId last_read_all_mentions_message_id; // all mentions with a message identifier not greater than it are implicitly read MessageId max_unavailable_message_id; // maximum unavailable message identifier for dialogs with cleared/unavailable history int64 order = DEFAULT_ORDER; int64 pending_order = DEFAULT_ORDER; MessageId deleted_last_message_id; int32 delete_last_message_date = 0; int32 last_clear_history_date = 0; MessageId last_clear_history_message_id; MessageId last_edited_message_id; uint32 scheduled_messages_sync_generation = 0; uint32 last_repair_scheduled_messages_generation = 0; MessageId max_added_message_id; MessageId being_added_message_id; MessageId being_updated_last_new_message_id; MessageId being_updated_last_database_message_id; MessageId being_deleted_message_id; bool has_contact_registered_message = false; bool is_last_message_deleted_locally = false; bool need_repair_action_bar = false; bool know_action_bar = false; bool has_outgoing_messages = false; bool was_opened = false; bool need_unload_on_close = false; bool need_restore_reply_markup = true; bool need_drop_default_send_message_as_dialog_id = false; bool have_full_history = false; bool is_empty = false; bool is_last_read_inbox_message_id_inited = false; bool is_last_read_outbox_message_id_inited = false; bool is_last_pinned_message_id_inited = false; bool is_folder_id_inited = false; bool need_repair_server_unread_count = false; bool need_repair_channel_server_unread_count = false; bool is_forum = false; bool view_as_messages = false; bool is_marked_as_unread = false; bool is_blocked = false; bool is_is_blocked_inited = false; bool is_blocked_for_stories = false; bool is_is_blocked_for_stories_inited = false; bool last_sent_has_scheduled_messages = false; bool has_scheduled_server_messages = false; bool has_scheduled_database_messages = false; bool is_has_scheduled_database_messages_checked = false; bool has_loaded_scheduled_messages_from_database = false; bool sent_scheduled_messages = false; bool had_last_yet_unsent_message = false; // whether the dialog was stored to database without last message bool has_active_group_call = false; bool is_group_call_empty = false; bool is_message_ttl_inited = false; bool has_expected_active_group_call_id = false; bool has_bots = false; bool is_view_as_messages_inited = false; bool is_saved_messages_view_as_messages_inited = false; bool is_has_bots_inited = false; bool is_background_inited = false; bool is_theme_name_inited = false; bool is_available_reactions_inited = false; bool had_yet_unsent_message_id_overflow = false; bool need_repair_unread_reaction_count = false; bool need_repair_unread_mention_count = false; bool is_translatable = false; bool is_update_new_chat_sent = false; bool is_update_new_chat_being_sent = false; bool has_unload_timeout = false; bool is_channel_difference_finished = false; int32 pts = 0; // for channels only int32 pending_read_channel_inbox_pts = 0; // for channels only int32 pending_read_channel_inbox_server_unread_count = 0; // for channels only MessageId pending_read_channel_inbox_max_message_id; // for channels only FlatHashMap random_id_to_message_id; // for secret chats and yet unsent messages only MessageId last_assigned_message_id; // identifier of the last local or yet unsent message, assigned after // application start, used to guarantee that all assigned message identifiers // are different WaitFreeHashSet deleted_message_ids; string client_data; WaitFreeHashMap, MessageIdHash> messages; mutable ListNode message_lru_list; OrderedMessages ordered_messages; unique_ptr scheduled_messages; const char *debug_set_dialog_last_database_message_id = "Unknown"; // to be removed soon // message identifiers loaded from database MessageId debug_last_new_message_id; MessageId debug_first_database_message_id; MessageId debug_last_database_message_id; Dialog() = default; Dialog(const Dialog &) = delete; Dialog &operator=(const Dialog &) = delete; Dialog(Dialog &&) = delete; Dialog &operator=(Dialog &&) = delete; ~Dialog() = default; template void store(StorerT &storer) const; template void parse(ParserT &parser); }; struct DialogList { DialogListId dialog_list_id; bool is_message_unread_count_inited_ = false; bool is_dialog_unread_count_inited_ = false; bool need_unread_count_recalc_ = true; int32 unread_message_total_count_ = 0; int32 unread_message_muted_count_ = 0; int32 unread_dialog_total_count_ = 0; int32 unread_dialog_muted_count_ = 0; int32 unread_dialog_marked_count_ = 0; int32 unread_dialog_muted_marked_count_ = 0; int32 in_memory_dialog_total_count_ = 0; int32 server_dialog_total_count_ = -1; int32 secret_chat_total_count_ = -1; int64 unique_id_ = 0; vector> load_list_queries_; FlatHashMap pinned_dialog_id_orders_; vector pinned_dialogs_; bool are_pinned_dialogs_inited_ = false; DialogDate last_pinned_dialog_date_ = MIN_DIALOG_DATE; // in memory // date of the last loaded dialog // min(folder1_last_dialog_date_, folder2_last_dialog_date, last_pinned_dialog_date_) DialogDate list_last_dialog_date_ = MIN_DIALOG_DATE; // in memory }; struct DialogFolder { FolderId folder_id; // date of the last loaded dialog in the folder DialogDate folder_last_dialog_date_{MAX_ORDINARY_DIALOG_ORDER, DialogId()}; // in memory std::set ordered_dialogs_; // all known dialogs, including with default order // date of last known user/group/channel dialog in the right order DialogDate last_server_dialog_date_{MAX_ORDINARY_DIALOG_ORDER, DialogId()}; DialogDate last_loaded_database_dialog_date_{MAX_ORDINARY_DIALOG_ORDER, DialogId()}; DialogDate last_database_server_dialog_date_{MAX_ORDINARY_DIALOG_ORDER, DialogId()}; MultiPromiseActor load_folder_dialog_list_multipromise_{ "LoadDialogListMultiPromiseActor"}; // must be defined before pending_on_get_dialogs_ int32 load_dialog_list_limit_max_ = 0; }; class DialogListViewIterator { MessagesManager *messages_manager_; const DialogListId *dialog_list_id_; public: DialogListViewIterator(MessagesManager *messages_manager, const DialogListId *dialog_list_id) : messages_manager_(messages_manager), dialog_list_id_(dialog_list_id) { } DialogList &operator*() const { auto dialog_list_ptr = messages_manager_->get_dialog_list(*dialog_list_id_); CHECK(dialog_list_ptr != nullptr); return *dialog_list_ptr; } bool operator!=(const DialogListViewIterator &other) const { return dialog_list_id_ != other.dialog_list_id_; } void operator++() { dialog_list_id_++; } }; class DialogListView { MessagesManager *messages_manager_; // TODO can be optimized to store only mask of dialog lists vector dialog_list_ids_; public: DialogListView(MessagesManager *messages_manager, vector dialog_list_ids) : messages_manager_(messages_manager), dialog_list_ids_(std::move(dialog_list_ids)) { } DialogListViewIterator begin() { return DialogListViewIterator(messages_manager_, dialog_list_ids_.empty() ? nullptr : &dialog_list_ids_[0]); } DialogListViewIterator end() { return DialogListViewIterator( messages_manager_, dialog_list_ids_.empty() ? nullptr : &dialog_list_ids_[0] + dialog_list_ids_.size()); } }; struct DialogPositionInList { int64 order = DEFAULT_ORDER; int64 private_order = 0; int64 public_order = 0; bool is_pinned = false; bool is_sponsored = false; int32 total_dialog_count = 0; friend StringBuilder &operator<<(StringBuilder &string_builder, const DialogPositionInList &order) { return string_builder << "order = " << order.order << ", private_order = " << order.private_order << ", public_order = " << order.public_order << ", is_pinned = " << order.is_pinned << ", is_sponsored = " << order.is_sponsored << ", total_dialog_count = " << order.total_dialog_count; } }; struct PendingSecretMessage { enum class Type : int32 { NewMessage, DeleteMessages, DeleteHistory }; Type type = Type::NewMessage; // for NewMessage MessageInfo message_info; MultiPromiseActor load_data_multipromise{"LoadPendingSecretMessageDataMultiPromiseActor"}; // for DeleteMessages/DeleteHistory DialogId dialog_id; vector random_ids; MessageId last_message_id; bool remove_from_dialog_list = false; Promise success_promise; }; struct MessageSendOptions { bool disable_notification = false; bool from_background = false; bool update_stickersets_order = false; bool protect_content = false; bool only_preview = false; int32 schedule_date = 0; int32 sending_id = 0; MessageEffectId effect_id; MessageSendOptions() = default; MessageSendOptions(bool disable_notification, bool from_background, bool update_stickersets_order, bool protect_content, bool only_preview, int32 schedule_date, int32 sending_id, MessageEffectId effect_id) : disable_notification(disable_notification) , from_background(from_background) , update_stickersets_order(update_stickersets_order) , protect_content(protect_content) , only_preview(only_preview) , schedule_date(schedule_date) , sending_id(sending_id) , effect_id(effect_id) { } }; struct SuffixLoadQueries { bool suffix_load_done_ = false; bool suffix_load_has_query_ = false; MessageId suffix_load_first_message_id_; // identifier of some message such all suffix messages in range // [suffix_load_first_message_id_, last_message_id] are loaded MessageId suffix_load_query_message_id_; vector, std::function>> suffix_load_queries_; }; struct PendingGetHistoryQuery { DialogId dialog_id_; MessageId from_message_id_; MessageId old_last_message_id_; int32 offset_ = 0; int32 limit_ = 0; bool from_database_ = false; bool only_local_ = false; bool operator==(const PendingGetHistoryQuery &other) const { return dialog_id_ == other.dialog_id_ && from_message_id_ == other.from_message_id_ && old_last_message_id_ == other.old_last_message_id_ && offset_ == other.offset_ && limit_ == other.limit_ && from_database_ == other.from_database_ && only_local_ == other.only_local_; } }; struct PendingGetHistoryQueryHash { uint32 operator()(const PendingGetHistoryQuery &query) const { uint32 hash = DialogIdHash()(query.dialog_id_); hash = combine_hashes(hash, MessageIdHash()(query.from_message_id_)); hash = combine_hashes(hash, MessageIdHash()(query.old_last_message_id_)); hash = combine_hashes(hash, Hash()(query.offset_)); hash = combine_hashes(hash, Hash()(query.limit_)); hash = combine_hashes(hash, static_cast(query.from_database_)); hash = combine_hashes(hash, static_cast(query.only_local_)); return hash; } }; class BlockMessageSenderFromRepliesOnServerLogEvent; class DeleteAllCallMessagesOnServerLogEvent; class DeleteAllChannelMessagesFromSenderOnServerLogEvent; class DeleteDialogHistoryOnServerLogEvent; class DeleteDialogMessagesByDateOnServerLogEvent; class DeleteMessageLogEvent; class DeleteMessagesOnServerLogEvent; class DeleteScheduledMessagesOnServerLogEvent; class DeleteTopicHistoryOnServerLogEvent; class ForwardMessagesLogEvent; class GetChannelDifferenceLogEvent; class ReadAllDialogMentionsOnServerLogEvent; class ReadAllDialogReactionsOnServerLogEvent; class ReadHistoryInSecretChatLogEvent; class ReadHistoryOnServerLogEvent; class ReadMessageContentsOnServerLogEvent; class ReadMessageThreadHistoryOnServerLogEvent; class RegetDialogLogEvent; class ReorderPinnedDialogsOnServerLogEvent; class ResetAllNotificationSettingsOnServerLogEvent; class SaveDialogDraftMessageOnServerLogEvent; class SendBotStartMessageLogEvent; class SendInlineQueryResultMessageLogEvent; class SendMessageLogEvent; class SendQuickReplyShortcutMessagesLogEvent; class SendScreenshotTakenNotificationMessageLogEvent; class SetDialogFolderIdOnServerLogEvent; class ToggleDialogIsBlockedOnServerLogEvent; class ToggleDialogViewAsMessagesOnServerLogEvent; class ToggleDialogIsMarkedAsUnreadOnServerLogEvent; class ToggleDialogIsTranslatableOnServerLogEvent; class ToggleDialogIsPinnedOnServerLogEvent; class ToggleDialogReportSpamStateOnServerLogEvent; class UnpinAllDialogMessagesOnServerLogEvent; class UpdateDialogNotificationSettingsOnServerLogEvent; static constexpr size_t MAX_GROUPED_MESSAGES = 10; // server side limit static constexpr int32 MAX_GET_DIALOGS = 100; // server side limit static constexpr int32 MAX_GET_HISTORY = 100; // server side limit static constexpr int32 MAX_SEARCH_MESSAGES = 100; // server side limit static constexpr int32 MIN_SEARCH_PUBLIC_DIALOG_PREFIX_LEN = 4; // server side limit static constexpr int32 MIN_CHANNEL_DIFFERENCE = 1; static constexpr int32 MAX_CHANNEL_DIFFERENCE = 100; static constexpr int32 MAX_BOT_CHANNEL_DIFFERENCE = 100000; // server side limit static constexpr int32 MAX_RECENT_DIALOGS = 50; // some reasonable value static constexpr size_t MIN_DELETED_ASYNCHRONOUSLY_MESSAGES = 2; static constexpr size_t MAX_UNLOADED_MESSAGES = 5000; static constexpr int64 SPONSORED_DIALOG_ORDER = static_cast(2147483647) << 32; static constexpr int32 MIN_PINNED_DIALOG_DATE = 2147000000; // some big date static constexpr int64 MAX_ORDINARY_DIALOG_ORDER = 9221294780217032704; // == get_dialog_order(MessageId(), MIN_PINNED_DIALOG_DATE - 1) static constexpr int32 CHANNEL_DIFFERENCE_FLAG_IS_FINAL = 1 << 0; static constexpr int32 CHANNEL_DIFFERENCE_FLAG_HAS_TIMEOUT = 1 << 1; static constexpr int32 DIALOG_FLAG_HAS_PTS = 1 << 0; static constexpr int32 DIALOG_FLAG_HAS_DRAFT = 1 << 1; static constexpr int32 DIALOG_FLAG_IS_PINNED = 1 << 2; static constexpr int32 DIALOG_FLAG_HAS_FOLDER_ID = 1 << 4; static constexpr int32 MAX_MESSAGE_VIEW_DELAY = 1; // seconds static constexpr int32 MIN_SAVE_DRAFT_DELAY = 1; // seconds static constexpr int32 MIN_READ_HISTORY_DELAY = 3; // seconds static constexpr int32 MAX_SAVE_DIALOG_DELAY = 0; // seconds static constexpr int32 DEFAULT_LOADED_EXPIRED_MESSAGES = 50; static constexpr int32 LIVE_LOCATION_VIEW_PERIOD = 60; // seconds, server-side limit static constexpr int32 UPDATE_VIEWED_MESSAGES_PERIOD = 15; // seconds static constexpr int32 AUTH_NOTIFICATION_ID_CACHE_TIME = 7 * 86400; static constexpr size_t MAX_SAVED_AUTH_NOTIFICATION_IDS = 100; static constexpr int32 MAX_RESEND_DELAY = 86400; // seconds, some resonable limit static constexpr int32 SCHEDULE_WHEN_ONLINE_DATE = 2147483646; static constexpr const char *DELETE_MESSAGE_USER_REQUEST_SOURCE = "user request"; static constexpr bool DROP_SEND_MESSAGE_UPDATES = false; vector get_message_user_ids(const Message *m) const; vector get_message_channel_ids(const Message *m) const; static bool is_dialog_inited(const Dialog *d); int32 get_dialog_mute_until(const Dialog *d) const; bool is_dialog_muted(const Dialog *d) const; bool is_dialog_pinned_message_notifications_disabled(const Dialog *d) const; bool is_dialog_mention_notifications_disabled(const Dialog *d) const; bool is_dialog_pinned(DialogListId dialog_list_id, DialogId dialog_id) const; int64 get_dialog_pinned_order(DialogListId dialog_list_id, DialogId dialog_id) const; static int64 get_dialog_pinned_order(const DialogList *list, DialogId dialog_id); void open_dialog(Dialog *d); void close_dialog(Dialog *d); void on_resolve_secret_chat_message_via_bot_username(const string &via_bot_username, MessageInfo *message_info_ptr, Promise &&promise); void add_secret_message(unique_ptr pending_secret_message, Promise lock_promise = {}); void on_add_secret_message_ready(int64 token); void finish_add_secret_message(unique_ptr pending_secret_message); void finish_delete_secret_messages(DialogId dialog_id, std::vector random_ids, Promise promise); void finish_delete_secret_chat_history(DialogId dialog_id, bool remove_from_dialog_list, MessageId last_message_id, Promise promise); static MessageInfo parse_telegram_api_message(Td *td, tl_object_ptr message_ptr, bool is_scheduled, const char *source); static std::pair> create_message(Td *td, MessageInfo &&message_info, bool is_channel_message, bool is_business_message, const char *source); MessageId find_old_message_id(DialogId dialog_id, MessageId message_id) const; void delete_update_message_id(DialogId dialog_id, MessageId message_id); void get_dialog_message_count_from_server(DialogId dialog_id, SavedMessagesTopicId saved_messages_topic_id, MessageSearchFilter filter, Promise &&promise); MessageFullId on_get_message(MessageInfo &&message_info, const bool from_update, const bool is_channel_message, const char *source); Result process_input_message_content( DialogId dialog_id, tl_object_ptr &&input_message_content, bool check_permissions = true); Result process_message_copy_options(DialogId dialog_id, tl_object_ptr &&options) const; Result process_message_send_options(DialogId dialog_id, tl_object_ptr &&options, bool allow_update_stickersets_order, bool allow_effect) const; static Status can_use_message_send_options(const MessageSendOptions &options, const unique_ptr &content, MessageSelfDestructType ttl); static Status can_use_message_send_options(const MessageSendOptions &options, const InputMessageContent &content); Status can_use_top_thread_message_id(Dialog *d, MessageId top_thread_message_id, const MessageInputReplyTo &input_reply_to); int64 generate_new_random_id(const Dialog *d); unique_ptr create_message_to_send(Dialog *d, MessageId top_thread_message_id, MessageInputReplyTo &&input_reply_to, const MessageSendOptions &options, unique_ptr &&content, bool invert_media, bool suppress_reply_info, unique_ptr forward_info, DialogId real_forward_from_dialog_id, bool is_copy, DialogId send_as_dialog_id) const; Message *get_message_to_send(Dialog *d, MessageId top_thread_message_id, MessageInputReplyTo &&input_reply_to, const MessageSendOptions &options, unique_ptr &&content, bool invert_media, bool *need_update_dialog_pos, bool suppress_reply_info = false, unique_ptr forward_info = nullptr, DialogId real_forward_from_dialog_id = DialogId(), bool is_copy = false, DialogId sender_dialog_id = DialogId()); int64 begin_send_message(DialogId dialog_id, const Message *m); Status can_send_message(DialogId dialog_id) const TD_WARN_UNUSED_RESULT; bool can_resend_message(const Message *m) const; bool can_edit_message(DialogId dialog_id, const Message *m, bool is_editing, bool only_reply_markup = false) const; static Status can_get_media_timestamp_link(DialogId dialog_id, const Message *m); bool can_report_message_reactions(DialogId dialog_id, const Message *m) const; Status can_get_message_read_date(DialogId dialog_id, const Message *m) const TD_WARN_UNUSED_RESULT; Status can_get_message_viewers(MessageFullId message_full_id) TD_WARN_UNUSED_RESULT; Status can_get_message_viewers(DialogId dialog_id, const Message *m) const TD_WARN_UNUSED_RESULT; void cancel_edit_message_media(DialogId dialog_id, Message *m, Slice error_message); void on_message_media_edited(DialogId dialog_id, MessageId message_id, FileId file_id, FileId thumbnail_file_id, bool was_uploaded, bool was_thumbnail_uploaded, string file_reference, int32 schedule_date, uint64 generation, Result &&result); MessageId get_persistent_message_id(const Dialog *d, MessageId message_id) const; static MessageFullId get_replied_message_id(DialogId dialog_id, const Message *m); MessageInputReplyTo create_message_input_reply_to(Dialog *d, MessageId top_thread_message_id, td_api::object_ptr &&reply_to, bool for_draft); static const MessageInputReplyTo *get_message_input_reply_to(const Message *m); bool can_set_game_score(DialogId dialog_id, const Message *m) const; void add_postponed_channel_update(DialogId dialog_id, tl_object_ptr &&update, int32 new_pts, int32 pts_count, Promise &&promise); bool process_channel_update(tl_object_ptr &&update_ptr); void on_message_edited(MessageFullId message_full_id, int32 pts, bool had_message); void delete_messages_from_updates(const vector &message_ids, bool is_permanent); void delete_dialog_messages(DialogId dialog_id, const vector &message_ids, bool force_update_for_not_found_messages, const char *source); void delete_dialog_messages(Dialog *d, const vector &message_ids, bool force_update_for_not_found_messages, const char *source); void update_dialog_pinned_messages_from_updates(DialogId dialog_id, const vector &message_ids, bool is_pin); bool update_message_is_pinned(Dialog *d, Message *m, bool is_pin, const char *source); void do_forward_messages(DialogId to_dialog_id, DialogId from_dialog_id, const vector &messages, const vector &message_ids, bool drop_author, bool drop_media_captions, uint64 log_event_id); uint64 save_send_quick_reply_shortcut_messages_log_event(DialogId dialog_id, QuickReplyShortcutId shortcut_id, const vector &messages, const vector &message_ids); void do_send_quick_reply_shortcut_messages(DialogId dialog_id, QuickReplyShortcutId shortcut_id, const vector &messages, const vector &message_ids, uint64 log_event_id); void send_send_quick_reply_messages_query(DialogId dialog_id, QuickReplyShortcutId shortcut_id, vector message_ids, vector random_ids, Promise promise); void send_forward_message_query(int32 flags, DialogId to_dialog_id, const MessageId top_thread_message_id, DialogId from_dialog_id, tl_object_ptr as_input_peer, vector message_ids, vector random_ids, int32 schedule_date, Promise promise); Result> forward_message(DialogId to_dialog_id, MessageId top_thread_message_id, DialogId from_dialog_id, MessageId message_id, td_api::object_ptr &&options, bool in_game_share, MessageCopyOptions &©_options) TD_WARN_UNUSED_RESULT; MessageOrigin get_forwarded_message_origin(DialogId dialog_id, const Message *m) const; unique_ptr create_message_forward_info(DialogId from_dialog_id, DialogId to_dialog_id, const Message *m) const; void fix_forwarded_message(Message *m, DialogId to_dialog_id, const Message *forwarded_message, int64 media_album_id, bool drop_author) const; struct ForwardedMessages { struct CopiedMessage { unique_ptr