tdlight/td/telegram/MessageContent.h

312 lines
14 KiB
C
Raw Normal View History

//
2022-12-31 22:28:08 +01:00
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2023
//
// 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
2023-04-10 16:23:21 +02:00
#include "td/telegram/BackgroundInfo.h"
2023-10-30 17:04:14 +01:00
#include "td/telegram/ChannelId.h"
#include "td/telegram/DialogId.h"
2021-08-01 05:17:51 +02:00
#include "td/telegram/EncryptedFile.h"
#include "td/telegram/files/FileId.h"
#include "td/telegram/InputGroupCallId.h"
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/MessageContentType.h"
#include "td/telegram/MessageCopyOptions.h"
#include "td/telegram/MessageEntity.h"
2023-09-21 18:11:17 +02:00
#include "td/telegram/MessageFullId.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/Photo.h"
#include "td/telegram/ReplyMarkup.h"
#include "td/telegram/secret_api.h"
#include "td/telegram/SecretInputMedia.h"
#include "td/telegram/StickerType.h"
2023-07-01 15:22:01 +02:00
#include "td/telegram/StoryFullId.h"
#include "td/telegram/td_api.h"
#include "td/telegram/telegram_api.h"
#include "td/telegram/TopDialogCategory.h"
#include "td/telegram/UserId.h"
#include "td/telegram/WebPageId.h"
#include "td/utils/buffer.h"
#include "td/utils/common.h"
2022-06-27 12:30:18 +02:00
#include "td/utils/Promise.h"
#include "td/utils/Status.h"
#include <utility>
namespace td {
class Dependencies;
class DialogAction;
class Game;
class MultiPromiseActor;
struct Photo;
2023-10-26 21:53:25 +02:00
class RepliedMessageInfo;
class Td;
2023-08-01 17:11:30 +02:00
class Venue;
2023-10-26 17:50:16 +02:00
// Do not forget to update merge_message_contents and compare_message_contents when one of the inheritors of this class changes
class MessageContent {
public:
MessageContent() = default;
MessageContent(const MessageContent &) = default;
MessageContent &operator=(const MessageContent &) = default;
MessageContent(MessageContent &&) = default;
MessageContent &operator=(MessageContent &&) = default;
virtual MessageContentType get_type() const = 0;
virtual ~MessageContent() = default;
};
struct InputMessageContent {
unique_ptr<MessageContent> content;
bool disable_web_page_preview = false;
bool invert_media = false;
bool clear_draft = false;
int32 ttl = 0;
UserId via_bot_user_id;
string emoji;
InputMessageContent(unique_ptr<MessageContent> &&content, bool disable_web_page_preview, bool invert_media,
bool clear_draft, int32 ttl, UserId via_bot_user_id, string emoji)
: content(std::move(content))
, disable_web_page_preview(disable_web_page_preview)
, invert_media(invert_media)
, clear_draft(clear_draft)
, ttl(ttl)
, via_bot_user_id(via_bot_user_id)
, emoji(std::move(emoji)) {
}
};
struct InlineMessageContent {
unique_ptr<MessageContent> message_content;
unique_ptr<ReplyMarkup> message_reply_markup;
bool disable_web_page_preview;
bool invert_media;
};
void store_message_content(const MessageContent *content, LogEventStorerCalcLength &storer);
void store_message_content(const MessageContent *content, LogEventStorerUnsafe &storer);
void parse_message_content(unique_ptr<MessageContent> &content, LogEventParser &parser);
InlineMessageContent create_inline_message_content(Td *td, FileId file_id,
tl_object_ptr<telegram_api::BotInlineMessage> &&bot_inline_message,
int32 allowed_media_content_id, Photo *photo, Game *game);
unique_ptr<MessageContent> create_text_message_content(string text, vector<MessageEntity> entities,
WebPageId web_page_id, bool force_small_media,
2023-10-19 12:03:27 +02:00
bool force_large_media, bool skip_confitmation,
string &&web_page_url);
unique_ptr<MessageContent> create_contact_registered_message_content();
unique_ptr<MessageContent> create_screenshot_taken_message_content();
2022-11-29 12:02:05 +01:00
unique_ptr<MessageContent> create_chat_set_ttl_message_content(int32 ttl, UserId from_user_id);
Result<InputMessageContent> get_input_message_content(
2022-06-03 15:33:49 +02:00
DialogId dialog_id, tl_object_ptr<td_api::InputMessageContent> &&input_message_content, Td *td, bool is_premium);
2022-05-08 22:54:04 +02:00
bool can_have_input_media(const Td *td, const MessageContent *content, bool is_server);
SecretInputMedia get_secret_input_media(const MessageContent *content, Td *td,
tl_object_ptr<telegram_api::InputEncryptedFile> input_file,
2022-05-11 06:46:06 +02:00
BufferSlice thumbnail, int32 layer);
tl_object_ptr<telegram_api::InputMedia> get_input_media(const MessageContent *content, Td *td,
tl_object_ptr<telegram_api::InputFile> input_file,
tl_object_ptr<telegram_api::InputFile> input_thumbnail,
FileId file_id, FileId thumbnail_file_id, int32 ttl,
2023-02-27 00:12:21 +01:00
const string &emoji, bool force);
tl_object_ptr<telegram_api::InputMedia> get_input_media(const MessageContent *content, Td *td, int32 ttl,
const string &emoji, bool force);
tl_object_ptr<telegram_api::InputMedia> get_fake_input_media(Td *td, tl_object_ptr<telegram_api::InputFile> input_file,
FileId file_id);
tl_object_ptr<telegram_api::InputMedia> get_message_content_input_media_web_page(const Td *td,
const MessageContent *content);
void delete_message_content_thumbnail(MessageContent *content, Td *td);
Status can_send_message_content(DialogId dialog_id, const MessageContent *content, bool is_forward, const Td *td);
bool can_forward_message_content(const MessageContent *content);
bool update_opened_message_content(MessageContent *content);
int32 get_message_content_index_mask(const MessageContent *content, const Td *td, bool is_outgoing);
StickerType get_message_content_sticker_type(const Td *td, const MessageContent *content);
MessageId get_message_content_pinned_message_id(const MessageContent *content);
2023-04-10 16:23:21 +02:00
BackgroundInfo get_message_content_background_info(const MessageContent *content);
2021-08-23 17:47:32 +02:00
string get_message_content_theme_name(const MessageContent *content);
2023-09-21 18:11:17 +02:00
MessageFullId get_message_content_replied_message_id(DialogId dialog_id, const MessageContent *content);
std::pair<InputGroupCallId, bool> get_message_content_group_call_info(const MessageContent *content);
vector<UserId> get_message_content_min_user_ids(const Td *td, const MessageContent *message_content);
vector<ChannelId> get_message_content_min_channel_ids(const Td *td, const MessageContent *message_content);
vector<UserId> get_message_content_added_user_ids(const MessageContent *content);
UserId get_message_content_deleted_user_id(const MessageContent *content);
int32 get_message_content_live_location_period(const MessageContent *content);
bool get_message_content_poll_is_anonymous(const Td *td, const MessageContent *content);
bool get_message_content_poll_is_closed(const Td *td, const MessageContent *content);
2023-08-01 17:11:30 +02:00
const Venue *get_message_content_venue(const MessageContent *content);
bool has_message_content_web_page(const MessageContent *content);
void remove_message_content_web_page(MessageContent *content);
bool can_message_content_have_media_timestamp(const MessageContent *content);
2023-09-21 18:11:17 +02:00
void set_message_content_poll_answer(Td *td, const MessageContent *content, MessageFullId message_full_id,
vector<int32> &&option_ids, Promise<Unit> &&promise);
2023-09-21 18:11:17 +02:00
void get_message_content_poll_voters(Td *td, const MessageContent *content, MessageFullId message_full_id,
int32 option_id, int32 offset, int32 limit,
2023-04-25 15:41:04 +02:00
Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
2023-09-21 18:11:17 +02:00
void stop_message_content_poll(Td *td, const MessageContent *content, MessageFullId message_full_id,
unique_ptr<ReplyMarkup> &&reply_markup, Promise<Unit> &&promise);
void merge_message_contents(Td *td, const MessageContent *old_content, MessageContent *new_content,
bool need_message_changed_warning, DialogId dialog_id, bool need_merge_files,
bool &is_content_changed, bool &need_update);
bool merge_message_content_file_id(Td *td, MessageContent *message_content, FileId new_file_id);
2023-10-26 17:50:16 +02:00
void compare_message_contents(Td *td, const MessageContent *lhs_content, const MessageContent *rhs_content,
bool &is_content_changed, bool &need_update);
2023-09-21 18:11:17 +02:00
void register_message_content(Td *td, const MessageContent *content, MessageFullId message_full_id, const char *source);
void reregister_message_content(Td *td, const MessageContent *old_content, const MessageContent *new_content,
2023-09-21 18:11:17 +02:00
MessageFullId message_full_id, const char *source);
2023-09-21 18:11:17 +02:00
void unregister_message_content(Td *td, const MessageContent *content, MessageFullId message_full_id,
const char *source);
2023-11-06 18:37:17 +01:00
void register_reply_message_content(Td *td, const MessageContent *content);
void unregister_reply_message_content(Td *td, const MessageContent *content);
unique_ptr<MessageContent> get_secret_message_content(
2021-08-01 05:17:51 +02:00
Td *td, string message_text, unique_ptr<EncryptedFile> file,
tl_object_ptr<secret_api::DecryptedMessageMedia> &&media_ptr,
vector<tl_object_ptr<secret_api::MessageEntity>> &&secret_entities, DialogId owner_dialog_id,
MultiPromiseActor &load_data_multipromise, bool is_premium);
unique_ptr<MessageContent> get_message_content(Td *td, FormattedText message_text,
tl_object_ptr<telegram_api::MessageMedia> &&media_ptr,
DialogId owner_dialog_id, bool is_content_read, UserId via_bot_user_id,
2022-08-01 13:45:44 +02:00
int32 *ttl, bool *disable_web_page_preview, const char *source);
enum class MessageContentDupType : int32 {
Send, // normal message sending
SendViaBot, // message sending via bot
Forward, // server-side message forward
Copy, // local message copy
ServerCopy // server-side message copy
};
unique_ptr<MessageContent> dup_message_content(Td *td, DialogId dialog_id, const MessageContent *content,
MessageContentDupType type, MessageCopyOptions &&copy_options);
unique_ptr<MessageContent> get_action_message_content(Td *td, tl_object_ptr<telegram_api::MessageAction> &&action_ptr,
2023-10-24 11:04:45 +02:00
DialogId owner_dialog_id,
const RepliedMessageInfo &replied_message_info);
tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageContent *content, Td *td,
DialogId dialog_id, int32 message_date,
2021-08-04 08:28:53 +02:00
bool is_content_secret, bool skip_bot_commands,
int32 max_media_timestamp, bool invert_media,
bool disable_web_page_preview);
FormattedText *get_message_content_text_mutable(MessageContent *content);
const FormattedText *get_message_content_text(const MessageContent *content);
const FormattedText *get_message_content_caption(const MessageContent *content);
bool get_message_content_has_spoiler(const MessageContent *content);
void set_message_content_has_spoiler(MessageContent *content, bool has_spoiler);
int32 get_message_content_duration(const MessageContent *content, const Td *td);
int32 get_message_content_media_duration(const MessageContent *content, const Td *td);
const Photo *get_message_content_photo(const MessageContent *content);
FileId get_message_content_upload_file_id(const MessageContent *content);
FileId get_message_content_any_file_id(const MessageContent *content);
void update_message_content_file_id_remote(MessageContent *content, FileId file_id);
FileId get_message_content_thumbnail_file_id(const MessageContent *content, const Td *td);
vector<FileId> get_message_content_file_ids(const MessageContent *content, const Td *td);
2023-06-22 21:39:47 +02:00
StoryFullId get_message_content_story_full_id(const Td *td, const MessageContent *content);
string get_message_content_search_text(const Td *td, const MessageContent *content);
bool update_message_content_extended_media(MessageContent *content,
telegram_api::object_ptr<telegram_api::MessageExtendedMedia> extended_media,
DialogId owner_dialog_id, Td *td);
2022-09-24 21:17:17 +02:00
bool need_poll_message_content_extended_media(const MessageContent *content);
2023-09-21 18:11:17 +02:00
void get_message_content_animated_emoji_click_sticker(const MessageContent *content, MessageFullId message_full_id,
2021-09-15 23:41:40 +02:00
Td *td, Promise<td_api::object_ptr<td_api::sticker>> &&promise);
2023-09-21 18:11:17 +02:00
void on_message_content_animated_emoji_clicked(const MessageContent *content, MessageFullId message_full_id, Td *td,
string &&emoji, string &&data);
2021-09-17 14:51:42 +02:00
bool need_reget_message_content(const MessageContent *content);
bool need_delay_message_content_notification(const MessageContent *content, UserId my_user_id);
void update_expired_message_content(unique_ptr<MessageContent> &content);
void update_failed_to_send_message_content(Td *td, unique_ptr<MessageContent> &content);
2023-01-10 14:20:30 +01:00
void add_message_content_dependencies(Dependencies &dependencies, const MessageContent *message_content, bool is_bot);
void update_forum_topic_info_by_service_message_content(Td *td, const MessageContent *content, DialogId dialog_id,
MessageId top_thread_message_id);
void on_sent_message_content(Td *td, const MessageContent *content);
2022-09-04 20:35:11 +02:00
void move_message_content_sticker_set_to_top(Td *td, const MessageContent *content);
bool is_unsent_animated_emoji_click(Td *td, DialogId dialog_id, const DialogAction &action);
void init_stickers_manager(Td *td);
void on_dialog_used(TopDialogCategory category, DialogId dialog_id, int32 date);
void update_used_hashtags(Td *td, const MessageContent *content);
} // namespace td