tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'td/master'

Browse Source
This commit is contained in:
Andrea Cavalli 2021-10-04 00:06:53 +02:00
commit 65f4b8ba57
6 changed files with 274 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
td/telegram/GameManager.cpp
View File

@ -242,7 +242,7 @@ void GameManager::set_game_score(FullMessageId full_message_id, bool edit_messag
void GameManager::on_set_game_score(FullMessageId full_message_id,
Promise<td_api::object_ptr<td_api::message>> &&promise) {
promise.set_value(td_->messages_manager_->get_message_object(full_message_id));
promise.set_value(td_->messages_manager_->get_message_object(full_message_id, "on_set_game_score"));
}
void GameManager::set_inline_game_score(const string &inline_message_id, bool edit_message, UserId user_id, int32 score,

289
td/telegram/MessagesManager.cpp
View File

@ -585,7 +585,7 @@ class UpdateDialogPinnedMessageQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) {
LOG(INFO) << "Can't update pinned message in " << dialog_id;
return on_error(0, Status::Error(500, "Can't update pinned message"));
return on_error(0, Status::Error(400, "Can't update pinned message"));
}
int32 flags = 0;
@ -628,7 +628,7 @@ class UnpinAllMessagesQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id_, AccessRights::Write);
if (input_peer == nullptr) {
LOG(INFO) << "Can't unpin all messages in " << dialog_id_;
return on_error(0, Status::Error(500, "Can't unpin all messages"));
return on_error(0, Status::Error(400, "Can't unpin all messages"));
}
send_query(G()->net_query_creator().create(telegram_api::messages_unpinAllMessages(std::move(input_peer))));
@ -1187,7 +1187,7 @@ class UploadImportedMediaQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) {
return on_error(0, Status::Error(400, "Have no write access to the chat"));
return on_error(0, Status::Error(400, "Can't access the chat"));
}
send_query(G()->net_query_creator().create(telegram_api::messages_uploadImportedMedia(
@ -1532,7 +1532,7 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) {
LOG(INFO) << "Can't update draft message because have no write access to " << dialog_id;
return on_error(0, Status::Error(500, "Can't save draft message"));
return on_error(0, Status::Error(400, "Can't save draft message"));
}
int32 flags = 0;
@ -1631,7 +1631,7 @@ class ToggleDialogPinQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_dialog_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
return on_error(0, Status::Error(500, "Can't update dialog is_pinned"));
return on_error(0, Status::Error(400, "Can't access the chat"));
}
int32 flags = 0;
@ -1721,7 +1721,7 @@ class ToggleDialogUnreadMarkQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_dialog_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
return on_error(0, Status::Error(500, "Can't update dialog is_marked_as_unread"));
return on_error(0, Status::Error(400, "Can't access the chat"));
}
int32 flags = 0;
@ -1817,8 +1817,7 @@ class GetMessagesViewsQuery final : public Td::ResultHandler {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
LOG(ERROR) << "Can't update message view count because doesn't have info about the " << dialog_id;
return on_error(0, Status::Error(500, "Can't update message view count"));
return on_error(0, Status::Error(400, "Can't access the chat"));
}
LOG(INFO) << "View " << message_ids_.size() << " messages in " << dialog_id
@ -1956,7 +1955,7 @@ class GetDialogMessageByDateQuery final : public Td::ResultHandler {
void send(DialogId dialog_id, int32 date, int64 random_id) {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
return promise_.set_error(Status::Error(500, "Have no info about the chat"));
return promise_.set_error(Status::Error(400, "Can't access the chat"));
}
dialog_id_ = dialog_id;
@ -2015,8 +2014,7 @@ class GetHistoryQuery final : public Td::ResultHandler {
int32 limit) {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
LOG(ERROR) << "Can't get chat history in " << dialog_id << " because doesn't have info about the chat";
return promise_.set_error(Status::Error(500, "Have no info about the chat"));
return promise_.set_error(Status::Error(400, "Can't access the chat"));
}
CHECK(offset < 0);
@ -2033,8 +2031,7 @@ class GetHistoryQuery final : public Td::ResultHandler {
void send_get_from_the_end(DialogId dialog_id, MessageId old_last_new_message_id, int32 limit) {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
LOG(ERROR) << "Can't get chat history because doesn't have info about the chat";
return promise_.set_error(Status::Error(500, "Have no info about the chat"));
return promise_.set_error(Status::Error(400, "Can't access the chat"));
}
dialog_id_ = dialog_id;
@ -2209,8 +2206,7 @@ class SearchMessagesQuery final : public Td::ResultHandler {
auto input_peer = dialog_id.is_valid() ? td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read)
: make_tl_object<telegram_api::inputPeerEmpty>();
if (input_peer == nullptr) {
LOG(ERROR) << "Can't search messages because doesn't have info about the chat";
return promise_.set_error(Status::Error(500, "Have no info about the chat"));
return promise_.set_error(Status::Error(400, "Can't access the chat"));
}
dialog_id_ = dialog_id;
@ -2296,6 +2292,55 @@ class SearchMessagesQuery final : public Td::ResultHandler {
}
};
class GetSearchCountersQuery final : public Td::ResultHandler {
Promise<int32> promise_;
DialogId dialog_id_;
MessageSearchFilter filter_;
public:
explicit GetSearchCountersQuery(Promise<int32> &&promise) : promise_(std::move(promise)) {
}
void send(DialogId dialog_id, MessageSearchFilter filter) {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
return promise_.set_error(Status::Error(400, "Can't access the chat"));
}
dialog_id_ = dialog_id;
filter_ = filter;
CHECK(filter != MessageSearchFilter::Empty);
CHECK(filter != MessageSearchFilter::UnreadMention);
CHECK(filter != MessageSearchFilter::FailedToSend);
vector<telegram_api::object_ptr<telegram_api::MessagesFilter>> filters;
filters.push_back(get_input_messages_filter(filter));
send_query(G()->net_query_creator().create(
telegram_api::messages_getSearchCounters(std::move(input_peer), std::move(filters))));
}
void on_result(uint64 id, BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::messages_getSearchCounters>(packet);
if (result_ptr.is_error()) {
return on_error(id, result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
if (result.size() != 1 || result[0]->filter_->get_id() != get_input_messages_filter(filter_)->get_id()) {
LOG(ERROR) << "Receive unexpected response for get message count in " << dialog_id_ << " with filter " << filter_
<< ": " << to_string(result);
return on_error(id, Status::Error(500, "Receive wrong response"));
}
td->messages_manager_->on_get_dialog_message_count(dialog_id_, filter_, result[0]->count_, std::move(promise_));
}
void on_error(uint64 id, Status status) final {
td->messages_manager_->on_get_dialog_error(dialog_id_, status, "GetSearchCountersQuery");
promise_.set_error(std::move(status));
}
};
class SearchMessagesGlobalQuery final : public Td::ResultHandler {
Promise<Unit> promise_;
string query_;
@ -2427,8 +2472,7 @@ class GetRecentLocationsQuery final : public Td::ResultHandler {
void send(DialogId dialog_id, int32 limit, int64 random_id) {
auto input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (input_peer == nullptr) {
LOG(ERROR) << "Can't get recent locations because doesn't have info about the chat";
return promise_.set_error(Status::Error(500, "Have no info about the chat"));
return on_error(0, Status::Error(400, "Have no info about the chat"));
}
dialog_id_ = dialog_id;
@ -8693,9 +8737,9 @@ void MessagesManager::do_send_media(DialogId dialog_id, Message *m, FileId file_
auto input_media = get_input_media(content, td_, std::move(input_file), std::move(input_thumbnail), file_id,
thumbnail_file_id, m->ttl, true);
LOG_CHECK(input_media != nullptr) << to_string(get_message_object(dialog_id, m)) << ' ' << have_input_file << ' '
<< have_input_thumbnail << ' ' << file_id << ' ' << thumbnail_file_id << ' '
<< m->ttl;
LOG_CHECK(input_media != nullptr) << to_string(get_message_object(dialog_id, m, "do_send_media")) << ' '
<< have_input_file << ' ' << have_input_thumbnail << ' ' << file_id << ' '
<< thumbnail_file_id << ' ' << m->ttl;
on_message_media_uploaded(dialog_id, m, std::move(input_media), file_id, thumbnail_file_id);
}
@ -9141,13 +9185,13 @@ void MessagesManager::after_get_difference() {
dump_debug_message_op(get_dialog(dialog_id));
}
if (message_id <= d->last_new_message_id) {
get_message_from_server(it.first, PromiseCreator::lambda([this, full_message_id](Result<Unit> result) {
get_message_from_server(
it.first, PromiseCreator::lambda([this, full_message_id](Result<Unit> result) {
if (result.is_error()) {
LOG(WARNING)
<< "Failed to get missing " << full_message_id << ": " << result.error();
LOG(WARNING) << "Failed to get missing " << full_message_id << ": " << result.error();
} else {
LOG(WARNING) << "Successfully get missing " << full_message_id << ": "
<< to_string(get_message_object(full_message_id));
<< to_string(get_message_object(full_message_id, "after_get_difference"));
}
}),
"get missing");
@ -9649,6 +9693,10 @@ void MessagesManager::on_get_dialog_messages_search_result(DialogId dialog_id, c
MessageId top_thread_message_id, int64 random_id,
int32 total_count,
vector<tl_object_ptr<telegram_api::Message>> &&messages) {
if (G()->close_flag()) {
return;
}
LOG(INFO) << "Receive " << messages.size() << " found messages in " << dialog_id;
if (!dialog_id.is_valid()) {
CHECK(query.empty());
@ -9778,7 +9826,6 @@ void MessagesManager::on_get_dialog_messages_search_result(DialogId dialog_id, c
bool from_the_end = !from_message_id.is_valid() ||
(d->last_message_id != MessageId() && from_message_id > d->last_message_id) ||
from_message_id >= MessageId::max();
if (G()->parameters().use_message_db) {
bool update_dialog = false;
auto &old_message_count = d->message_count_by_index[message_search_filter_index(filter)];
@ -9792,16 +9839,16 @@ void MessagesManager::on_get_dialog_messages_search_result(DialogId dialog_id, c
update_dialog = true;
}
auto &old_first_db_message_id = d->first_database_message_id_by_index[message_search_filter_index(filter)];
if ((from_the_end || (old_first_db_message_id.is_valid() && old_first_db_message_id <= from_message_id)) &&
(!old_first_db_message_id.is_valid() || first_added_message_id < old_first_db_message_id)) {
old_first_db_message_id = first_added_message_id;
auto &old_first_database_message_id = d->first_database_message_id_by_index[message_search_filter_index(filter)];
if ((from_the_end ||
(old_first_database_message_id.is_valid() && old_first_database_message_id <= from_message_id)) &&
(!old_first_database_message_id.is_valid() || first_added_message_id < old_first_database_message_id)) {
old_first_database_message_id = first_added_message_id;
update_dialog = true;
}
if (update_dialog) {
on_dialog_updated(dialog_id, "search results");
}
}
if (from_the_end && filter == MessageSearchFilter::Pinned) {
set_dialog_last_pinned_message_id(d, result.empty() ? MessageId() : result[0]);
@ -9824,6 +9871,39 @@ void MessagesManager::on_failed_dialog_messages_search(DialogId dialog_id, int64
found_dialog_messages_.erase(it);
}
void MessagesManager::on_get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, int32 total_count,
Promise<int32> &&promise) {
LOG(INFO) << "Receive " << total_count << " message count in " << dialog_id << " with filter " << filter;
if (total_count < 0) {
LOG(ERROR) << "Receive total message count = " << total_count << " in " << dialog_id << " with filter " << filter;
total_count = 0;
}
Dialog *d = get_dialog(dialog_id);
CHECK(d != nullptr);
CHECK(filter != MessageSearchFilter::Empty);
CHECK(filter != MessageSearchFilter::UnreadMention);
CHECK(filter != MessageSearchFilter::FailedToSend);
auto &old_message_count = d->message_count_by_index[message_search_filter_index(filter)];
if (old_message_count != total_count) {
old_message_count = total_count;
on_dialog_updated(dialog_id, "on_get_dialog_message_count");
}
if (total_count == 0) {
auto &old_first_database_message_id = d->first_database_message_id_by_index[message_search_filter_index(filter)];
if (old_first_database_message_id != MessageId::min()) {
old_first_database_message_id = MessageId::min();
on_dialog_updated(dialog_id, "on_get_dialog_message_count");
}
if (filter == MessageSearchFilter::Pinned) {
set_dialog_last_pinned_message_id(d, MessageId());
}
}
promise.set_value(std::move(total_count));
}
void MessagesManager::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,
@ -9978,7 +10058,7 @@ void MessagesManager::on_get_message_public_forwards(int32 total_count,
false, false, false, "get message public forwards");
if (new_full_message_id != FullMessageId()) {
CHECK(dialog_id == new_full_message_id.get_dialog_id());
result.push_back(get_message_object(new_full_message_id));
result.push_back(get_message_object(new_full_message_id, "on_get_message_public_forwards"));
CHECK(result.back() != nullptr);
last_full_message_id = new_full_message_id;
} else {
@ -13647,10 +13727,9 @@ FullMessageId MessagesManager::on_get_message(MessageInfo &&message_info, bool f
<< " with identifier less than last_new_message_id = " << d->last_new_message_id
<< " and trying to add it anyway";
} else {
// TODO move to INFO
LOG(ERROR) << "Ignore " << old_message_id << "/" << message_id << " received not through update from " << source
<< ": "
<< oneline(to_string(get_message_object(dialog_id, new_message.get()))); // TODO move to INFO
dump_debug_message_op(d, 3); // TODO remove
<< ": " << oneline(to_string(get_message_object(dialog_id, new_message.get(), "on_get_message")));
if (dialog_id.get_type() == DialogType::Channel && have_input_peer(dialog_id, AccessRights::Read)) {
channel_get_difference_retry_timeout_.add_timeout_in(dialog_id.get(), 0.001);
}
@ -17180,7 +17259,7 @@ td_api::object_ptr<td_api::messageThreadInfo> MessagesManager::get_message_threa
messages.reserve(info.message_ids.size());
for (auto message_id : info.message_ids) {
const Message *m = get_message_force(d, message_id, "get_message_thread_info_object");
auto message = get_message_object(d->dialog_id, m);
auto message = get_message_object(d->dialog_id, m, "get_message_thread_info_object");
if (message != nullptr) {
if (message->interaction_info_ != nullptr && message->interaction_info_->reply_info_ != nullptr) {
reply_info = m->reply_info.get_message_reply_info_object(td_->contacts_manager_.get(), this);
@ -17902,7 +17981,7 @@ td_api::object_ptr<td_api::messageLinkInfo> MessagesManager::get_message_link_in
} else {
const Message *m = get_message(d, message_id);
if (m != nullptr) {
message = get_message_object(dialog_id, m);
message = get_message_object(dialog_id, m, "get_message_link_info_object");
for_album = !info.is_single && m->media_album_id != 0;
for_comment = (info.comment_dialog_id.is_valid() || info.for_comment) && m->top_thread_message_id.is_valid();
if (can_message_content_have_media_timestamp(m->content.get())) {
@ -20182,11 +20261,11 @@ td_api::object_ptr<td_api::chat> MessagesManager::get_chat_object(const Dialog *
d->dialog_id.get(), get_chat_type_object(d->dialog_id), get_dialog_title(d->dialog_id),
get_chat_photo_info_object(td_->file_manager_.get(), get_dialog_photo(d->dialog_id)),
get_dialog_permissions(d->dialog_id).get_chat_permissions_object(),
get_message_object(d->dialog_id, get_message(d, d->last_message_id)), get_chat_positions_object(d),
d->is_marked_as_unread, d->is_blocked, get_dialog_has_scheduled_messages(d), can_delete_for_self,
can_delete_for_all_users, can_report_dialog(d->dialog_id), d->notification_settings.silent_send_message,
d->server_unread_count + d->local_unread_count, d->last_read_inbox_message_id.get(),
d->last_read_outbox_message_id.get(), d->unread_mention_count,
get_message_object(d->dialog_id, get_message(d, d->last_message_id), "get_chat_object"),
get_chat_positions_object(d), d->is_marked_as_unread, d->is_blocked, get_dialog_has_scheduled_messages(d),
can_delete_for_self, can_delete_for_all_users, can_report_dialog(d->dialog_id),
d->notification_settings.silent_send_message, d->server_unread_count + d->local_unread_count,
d->last_read_inbox_message_id.get(), d->last_read_outbox_message_id.get(), d->unread_mention_count,
get_chat_notification_settings_object(&d->notification_settings),
d->message_ttl_setting.get_message_ttl_setting_object(), get_dialog_theme_name(d), get_chat_action_bar_object(d),
get_voice_chat_object(d), d->reply_markup_message_id.get(), std::move(draft_message), d->client_data);
@ -20653,7 +20732,7 @@ tl_object_ptr<td_api::messages> MessagesManager::get_dialog_history(DialogId dia
vector<tl_object_ptr<td_api::message>> messages;
if (*p != nullptr && offset == 0) {
while (*p != nullptr && messages.size() < static_cast<size_t>(limit)) {
messages.push_back(get_message_object(dialog_id, *p));
messages.push_back(get_message_object(dialog_id, *p, "get_dialog_history"));
from_message_id = (*p)->message_id;
from_the_end = false;
--p;
@ -21896,11 +21975,11 @@ void MessagesManager::on_search_dialog_messages_db_result(int64 random_id, Dialo
}
td_api::object_ptr<td_api::foundMessages> MessagesManager::get_found_messages_object(
const FoundMessages &found_messages) {
const FoundMessages &found_messages, const char *source) {
vector<tl_object_ptr<td_api::message>> result;
result.reserve(found_messages.full_message_ids.size());
for (auto full_message_id : found_messages.full_message_ids) {
auto message = get_message_object(full_message_id);
auto message = get_message_object(full_message_id, source);
if (message != nullptr) {
result.push_back(std::move(message));
}
@ -22259,69 +22338,46 @@ tl_object_ptr<td_api::message> MessagesManager::get_dialog_message_by_date_objec
CHECK(it != get_dialog_message_by_date_results_.end());
auto full_message_id = std::move(it->second);
get_dialog_message_by_date_results_.erase(it);
return get_message_object(full_message_id);
}
int32 MessagesManager::get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, bool return_local,
int64 &random_id, Promise<Unit> &&promise) {
if (random_id != 0) {
// request has already been sent before
auto it = found_dialog_messages_.find(random_id);
CHECK(it != found_dialog_messages_.end());
auto result = std::move(it->second);
found_dialog_messages_.erase(it);
CHECK(found_dialog_messages_dialog_id_.count(random_id) == 0);
promise.set_value(Unit());
return result.first;
return get_message_object(full_message_id, "get_dialog_message_by_date_object");
}
void MessagesManager::get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, bool return_local,
Promise<int32> &&promise) {
LOG(INFO) << "Get " << (return_local ? "local " : "") << "number of messages in " << dialog_id << " filtered by "
<< filter;
const Dialog *d = get_dialog_force(dialog_id, "get_dialog_message_count");
if (d == nullptr) {
promise.set_error(Status::Error(400, "Chat not found"));
return -1;
return promise.set_error(Status::Error(400, "Chat not found"));
}
if (filter == MessageSearchFilter::Empty) {
promise.set_error(Status::Error(400, "Can't use searchMessagesFilterEmpty"));
return -1;
return promise.set_error(Status::Error(400, "Can't use searchMessagesFilterEmpty"));
}
auto dialog_type = dialog_id.get_type();
int32 message_count = d->message_count_by_index[message_search_filter_index(filter)];
if (message_count == -1) {
if (filter == MessageSearchFilter::UnreadMention) {
if (message_count == -1 && filter == MessageSearchFilter::UnreadMention) {
message_count = d->unread_mention_count;
}
}
if (message_count != -1 || return_local || dialog_type == DialogType::SecretChat ||
filter == MessageSearchFilter::FailedToSend) {
promise.set_value(Unit());
return message_count;
return promise.set_value(std::move(message_count));
}
LOG(INFO) << "Get number of messages in " << dialog_id << " filtered by " << filter << " from the server";
do {
random_id = Random::secure_int64();
} while (random_id == 0 || found_dialog_messages_.find(random_id) != found_dialog_messages_.end());
found_dialog_messages_[random_id]; // reserve place for result
switch (dialog_id.get_type()) {
case DialogType::User:
case DialogType::Chat:
case DialogType::Channel:
td_->create_handler<SearchMessagesQuery>(std::move(promise))
->send(dialog_id, "", DialogId(), MessageId(), 0, 1, filter, MessageId(), random_id);
td_->create_handler<GetSearchCountersQuery>(std::move(promise))->send(dialog_id, filter);
break;
case DialogType::None:
case DialogType::SecretChat:
default:
UNREACHABLE();
}
return -1;
}
void MessagesManager::preload_newer_messages(const Dialog *d, MessageId max_message_id) {
@ -22539,7 +22595,8 @@ void MessagesManager::on_get_history_from_database(DialogId dialog_id, MessageId
<< ' ' << from_message_id << ' ' << offset << ' ' << limit << ' ' << from_the_end << ' ' << only_local
<< ' ' << messages.size() << ' ' << debug_first_database_message_id << ' ' << last_added_message_id << ' '
<< added_new_message << ' ' << pos << ' ' << m << ' ' << next_message << ' ' << old_message << ' '
<< to_string(get_message_object(dialog_id, m)) << to_string(get_message_object(dialog_id, next_message));
<< to_string(get_message_object(dialog_id, m, "on_get_history_from_database"))
<< to_string(get_message_object(dialog_id, next_message, "on_get_history_from_database"));
LOG(INFO) << "Fix have_previous for " << next_message->message_id;
next_message->have_previous = true;
attach_message_to_previous(
@ -23074,15 +23131,16 @@ tl_object_ptr<td_api::MessageSchedulingState> MessagesManager::get_message_sched
return td_api::make_object<td_api::messageSchedulingStateSendAtDate>(send_date);
}
tl_object_ptr<td_api::message> MessagesManager::get_message_object(FullMessageId full_message_id) {
return get_message_object(full_message_id.get_dialog_id(), get_message_force(full_message_id, "get_message_object"));
tl_object_ptr<td_api::message> MessagesManager::get_message_object(FullMessageId full_message_id, const char *source) {
return get_message_object(full_message_id.get_dialog_id(), get_message_force(full_message_id, source), source);
}
tl_object_ptr<td_api::message> MessagesManager::get_message_object(DialogId dialog_id, const Message *m,
bool for_event_log) const {
const char *source, bool for_event_log) const {
if (m == nullptr) {
return nullptr;
}
LOG_CHECK(have_dialog(dialog_id)) << source;
m->is_update_sent = true;
@ -23169,9 +23227,8 @@ tl_object_ptr<td_api::message> MessagesManager::get_message_object(DialogId dial
int32 max_media_timestamp =
for_event_log ? get_message_own_max_media_timestamp(m) : get_message_max_media_timestamp(m);
bool has_timestamped_media = for_event_log || reply_to_message_id == 0 || m->max_own_media_timestamp >= 0;
string source = PSTRING() << dialog_id << ' ' << m->message_id;
return make_tl_object<td_api::message>(
m->message_id.get(), get_message_sender_object_const(m->sender_user_id, m->sender_dialog_id, source.c_str()),
m->message_id.get(), get_message_sender_object_const(m->sender_user_id, m->sender_dialog_id, source),
dialog_id.get(), std::move(sending_state), std::move(scheduling_state), is_outgoing, is_pinned, can_be_edited,
can_be_forwarded, can_delete_for_self, can_delete_for_all_users, can_get_statistics, can_get_message_thread,
can_get_viewers, can_get_media_timestamp_links, has_timestamped_media, m->is_channel_post,
@ -23186,20 +23243,21 @@ tl_object_ptr<td_api::message> MessagesManager::get_message_object(DialogId dial
tl_object_ptr<td_api::messages> MessagesManager::get_messages_object(int32 total_count, DialogId dialog_id,
const vector<MessageId> &message_ids,
bool skip_not_found) {
bool skip_not_found, const char *source) {
Dialog *d = get_dialog(dialog_id);
CHECK(d != nullptr);
auto message_objects = transform(message_ids, [this, dialog_id, d](MessageId message_id) {
return get_message_object(dialog_id, get_message_force(d, message_id, "get_messages_object"));
auto message_objects = transform(message_ids, [this, dialog_id, d, source](MessageId message_id) {
return get_message_object(dialog_id, get_message_force(d, message_id, source), source);
});
return get_messages_object(total_count, std::move(message_objects), skip_not_found);
}
tl_object_ptr<td_api::messages> MessagesManager::get_messages_object(int32 total_count,
const vector<FullMessageId> &full_message_ids,
bool skip_not_found) {
auto message_objects = transform(
full_message_ids, [this](FullMessageId full_message_id) { return get_message_object(full_message_id); });
bool skip_not_found, const char *source) {
auto message_objects = transform(full_message_ids, [this, source](FullMessageId full_message_id) {
return get_message_object(full_message_id, source);
});
return get_messages_object(total_count, std::move(message_objects), skip_not_found);
}
@ -23714,7 +23772,7 @@ Result<td_api::object_ptr<td_api::message>> MessagesManager::send_message(
send_update_chat_last_message(d, "send_message");
}
return get_message_object(dialog_id, m);
return get_message_object(dialog_id, m, "send_message");
}
Result<InputMessageContent> MessagesManager::process_input_message_content(
@ -26593,7 +26651,7 @@ Result<td_api::object_ptr<td_api::messages>> MessagesManager::forward_messages(
forwarded_message_ids.push_back(message_id);
}
result[forwarded_message_contents[j].index] = get_message_object(to_dialog_id, m, false);
result[forwarded_message_contents[j].index] = get_message_object(to_dialog_id, m, "forward_messages");
}
if (!forwarded_messages.empty()) {
@ -26629,7 +26687,7 @@ Result<td_api::object_ptr<td_api::messages>> MessagesManager::forward_messages(
send_update_new_message(to_dialog, m);
}
result[copied_message.index] = get_message_object(to_dialog_id, m, false);
result[copied_message.index] = get_message_object(to_dialog_id, m, "forward_messages");
}
if (need_update_dialog_pos) {
@ -27255,8 +27313,9 @@ void MessagesManager::send_update_new_message(const Dialog *d, const Message *m)
CHECK(d != nullptr);
CHECK(m != nullptr);
CHECK(d->is_update_new_chat_sent);
send_closure(G()->td(), &Td::send_update,
make_tl_object<td_api::updateNewMessage>(get_message_object(d->dialog_id, m)));
send_closure(
G()->td(), &Td::send_update,
make_tl_object<td_api::updateNewMessage>(get_message_object(d->dialog_id, m, "send_update_new_message")));
}
MessagesManager::NotificationGroupInfo &MessagesManager::get_notification_group_info(Dialog *d, const Message *m) {
@ -28506,9 +28565,9 @@ void MessagesManager::send_update_message_send_succeeded(Dialog *d, MessageId ol
if (!td_->auth_manager_->is_bot()) {
d->yet_unsent_message_id_to_persistent_message_id.emplace(old_message_id, m->message_id);
}
send_closure(
G()->td(), &Td::send_update,
make_tl_object<td_api::updateMessageSendSucceeded>(get_message_object(d->dialog_id, m), old_message_id.get()));
send_closure(G()->td(), &Td::send_update,
make_tl_object<td_api::updateMessageSendSucceeded>(
get_message_object(d->dialog_id, m, "send_update_message_send_succeeded"), old_message_id.get()));
}
void MessagesManager::send_update_message_content(DialogId dialog_id, Message *m, bool is_message_in_dialog,
@ -28640,7 +28699,8 @@ void MessagesManager::send_update_chat_last_message_impl(const Dialog *d, const
<< source;
LOG(INFO) << "Send updateChatLastMessage in " << d->dialog_id << " to " << d->last_message_id << " from " << source;
auto update = make_tl_object<td_api::updateChatLastMessage>(
d->dialog_id.get(), get_message_object(d->dialog_id, get_message(d, d->last_message_id)),
d->dialog_id.get(),
get_message_object(d->dialog_id, get_message(d, d->last_message_id), "send_update_chat_last_message_impl"),
get_chat_positions_object(d));
send_closure(G()->td(), &Td::send_update, std::move(update));
}
@ -29448,7 +29508,8 @@ void MessagesManager::on_send_message_fail(int64 random_id, Status error) {
}
if (error.message() == "REPLY_MARKUP_INVALID") {
if (m->reply_markup == nullptr) {
LOG(ERROR) << "Receive " << error.message() << " for " << oneline(to_string(get_message_object(dialog_id, m)));
LOG(ERROR) << "Receive " << error.message() << " for "
<< oneline(to_string(get_message_object(dialog_id, m, "on_send_message_fail")));
} else {
LOG(ERROR) << "Receive " << error.message() << " for " << full_message_id << " with keyboard "
<< *m->reply_markup;
@ -29595,8 +29656,8 @@ void MessagesManager::fail_send_message(FullMessageId full_message_id, int error
d->yet_unsent_message_id_to_persistent_message_id.emplace(old_message_id, m->message_id);
}
send_closure(G()->td(), &Td::send_update,
make_tl_object<td_api::updateMessageSendFailed>(get_message_object(dialog_id, m), old_message_id.get(),
error_code, error_message));
make_tl_object<td_api::updateMessageSendFailed>(get_message_object(dialog_id, m, "fail_send_message"),
old_message_id.get(), error_code, error_message));
if (need_update_dialog_pos) {
send_update_chat_last_message(d, "fail_send_message");
}
@ -31869,11 +31930,11 @@ tl_object_ptr<td_api::ChatEventAction> MessagesManager::get_chat_event_action_ob
auto message = create_message(
parse_telegram_api_message(std::move(action->message_), false, "channelAdminLogEventActionUpdatePinned"),
true);
if (message.second == nullptr) {
if (message.second == nullptr || message.first != DialogId(channel_id)) {
LOG(ERROR) << "Failed to get pinned message";
return nullptr;
}
auto message_object = get_message_object(message.first, message.second.get(), true);
auto message_object = get_message_object(message.first, message.second.get(), "admin log", true);
if (message.second->is_pinned) {
return make_tl_object<td_api::chatEventMessagePinned>(std::move(message_object));
} else {
@ -31888,19 +31949,20 @@ tl_object_ptr<td_api::ChatEventAction> MessagesManager::get_chat_event_action_ob
auto new_message = create_message(parse_telegram_api_message(std::move(action->new_message_), false,
"new channelAdminLogEventActionEditMessage"),
true);
if (old_message.second == nullptr || new_message.second == nullptr || old_message.first != new_message.first) {
if (old_message.second == nullptr || new_message.second == nullptr || old_message.first != new_message.first ||
old_message.first != DialogId(channel_id)) {
LOG(ERROR) << "Failed to get edited message";
return nullptr;
}
return make_tl_object<td_api::chatEventMessageEdited>(
get_message_object(old_message.first, old_message.second.get(), true),
get_message_object(new_message.first, new_message.second.get(), true));
get_message_object(old_message.first, old_message.second.get(), "admin log", true),
get_message_object(new_message.first, new_message.second.get(), "admin log", true));
}
case telegram_api::channelAdminLogEventActionStopPoll::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionStopPoll>(action_ptr);
auto message = create_message(
parse_telegram_api_message(std::move(action->message_), false, "channelAdminLogEventActionStopPoll"), true);
if (message.second == nullptr) {
if (message.second == nullptr || message.first != DialogId(channel_id)) {
LOG(ERROR) << "Failed to get stopped poll message";
return nullptr;
}
@ -31909,19 +31971,19 @@ tl_object_ptr<td_api::ChatEventAction> MessagesManager::get_chat_event_action_ob
return nullptr;
}
return make_tl_object<td_api::chatEventPollStopped>(
get_message_object(message.first, message.second.get(), true));
get_message_object(message.first, message.second.get(), "admin log", true));
}
case telegram_api::channelAdminLogEventActionDeleteMessage::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionDeleteMessage>(action_ptr);
auto message = create_message(
parse_telegram_api_message(std::move(action->message_), false, "channelAdminLogEventActionDeleteMessage"),
true);
if (message.second == nullptr) {
if (message.second == nullptr || message.first != DialogId(channel_id)) {
LOG(ERROR) << "Failed to get deleted message";
return nullptr;
}
return make_tl_object<td_api::chatEventMessageDeleted>(
get_message_object(message.first, message.second.get(), true));
get_message_object(message.first, message.second.get(), "admin log", true));
}
case telegram_api::channelAdminLogEventActionChangeStickerSet::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionChangeStickerSet>(action_ptr);
@ -32500,7 +32562,7 @@ MessagesManager::Message *MessagesManager::add_message_to_dialog(Dialog *d, uniq
<< ". The maximum allowed is " << max_message_id << ", last is " << d->last_message_id
<< ", being added message is " << d->being_added_message_id << ", channel difference "
<< debug_channel_difference_dialog_ << " "
<< to_string(get_message_object(dialog_id, message.get()));
<< to_string(get_message_object(dialog_id, message.get(), "add_message_to_dialog"));
dump_debug_message_op(d, 3);
if (need_channel_difference_to_add_message(dialog_id, nullptr)) {
@ -33936,8 +33998,8 @@ bool MessagesManager::update_message(Dialog *d, Message *old_message, unique_ptr
LOG_IF(ERROR, old_message->edit_date == 0 && is_new_available && !replace_legacy)
<< "Disable_notification has changed from " << old_message->disable_notification << " to "
<< new_message->disable_notification
<< ". Old message: " << to_string(get_message_object(dialog_id, old_message))
<< ". New message: " << to_string(get_message_object(dialog_id, new_message.get()));
<< ". Old message: " << to_string(get_message_object(dialog_id, old_message, "update_message"))
<< ". New message: " << to_string(get_message_object(dialog_id, new_message.get(), "update_message"));
// disable_notification flag shouldn't be changed, because we are unable to show/hide message notification
// old_message->disable_notification = new_message->disable_notification;
// need_send_update = true;
@ -34035,8 +34097,9 @@ bool MessagesManager::update_message(Dialog *d, Message *old_message, unique_ptr
if (need_message_changed_warning(old_message) && is_new_available) {
LOG(ERROR) << message_id << " in " << dialog_id << " sent by " << old_message->sender_user_id << "/"
<< old_message->sender_dialog_id << " has lost reply markup " << *old_message->reply_markup
<< ". Old message: " << to_string(get_message_object(dialog_id, old_message))
<< ". New message: " << to_string(get_message_object(dialog_id, new_message.get()));
<< ". Old message: " << to_string(get_message_object(dialog_id, old_message, "update_message"))
<< ". New message: "
<< to_string(get_message_object(dialog_id, new_message.get(), "update_message"));
}
}
}

19
td/telegram/MessagesManager.h
View File

@ -214,6 +214,9 @@ class MessagesManager final : public Actor {
vector<tl_object_ptr<telegram_api::Message>> &&messages);
void on_failed_dialog_messages_search(DialogId dialog_id, int64 random_id);
void on_get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, int32 total_count,
Promise<int32> &&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, int64 random_id, int32 total_count,
@ -702,7 +705,8 @@ class MessagesManager final : public Actor {
int32 total_count = 0;
};
td_api::object_ptr<td_api::foundMessages> get_found_messages_object(const FoundMessages &found_messages);
td_api::object_ptr<td_api::foundMessages> get_found_messages_object(const FoundMessages &found_messages,
const char *source);
FoundMessages offline_search_messages(DialogId dialog_id, const string &query, const string &offset, int32 limit,
MessageSearchFilter filter, int64 &random_id, Promise<> &&promise);
@ -728,8 +732,8 @@ class MessagesManager final : public Actor {
void on_get_dialog_message_by_date_fail(int64 random_id);
int32 get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, bool return_local, int64 &random_id,
Promise<Unit> &&promise);
void get_dialog_message_count(DialogId dialog_id, MessageSearchFilter filter, bool return_local,
Promise<int32> &&promise);
vector<MessageId> get_dialog_scheduled_messages(DialogId dialog_id, bool force, bool ignore_result,
Promise<Unit> &&promise);
@ -739,13 +743,14 @@ class MessagesManager final : public Actor {
tl_object_ptr<td_api::message> get_dialog_message_by_date_object(int64 random_id);
tl_object_ptr<td_api::message> get_message_object(FullMessageId full_message_id);
tl_object_ptr<td_api::message> get_message_object(FullMessageId full_message_id, const char *source);
tl_object_ptr<td_api::messages> get_messages_object(int32 total_count, DialogId dialog_id,
const vector<MessageId> &message_ids, bool skip_not_found);
const vector<MessageId> &message_ids, bool skip_not_found,
const char *source);
tl_object_ptr<td_api::messages> get_messages_object(int32 total_count, const vector<FullMessageId> &full_message_ids,
bool skip_not_found);
bool skip_not_found, const char *source);
void process_pts_update(tl_object_ptr<telegram_api::Update> &&update);
@ -2350,7 +2355,7 @@ class MessagesManager final : public Actor {
static tl_object_ptr<td_api::MessageSchedulingState> get_message_scheduling_state_object(int32 send_date);
tl_object_ptr<td_api::message> get_message_object(DialogId dialog_id, const Message *m,
tl_object_ptr<td_api::message> get_message_object(DialogId dialog_id, const Message *m, const char *source,
bool for_event_log = false) const;
static tl_object_ptr<td_api::messages> get_messages_object(int32 total_count,

3
td/telegram/NotificationType.cpp
View File

@ -42,7 +42,8 @@ class NotificationTypeMessage final : public NotificationType {
}
td_api::object_ptr<td_api::NotificationType> get_notification_type_object(DialogId dialog_id) const final {
auto message_object = G()->td().get_actor_unsafe()->messages_manager_->get_message_object({dialog_id, message_id_});
auto message_object = G()->td().get_actor_unsafe()->messages_manager_->get_message_object(
{dialog_id, message_id_}, "get_notification_type_object");
if (message_object == nullptr) {
return nullptr;
}

146
td/telegram/Td.cpp
View File

@ -471,9 +471,11 @@ class SaveAppLogQuery final : public Td::ResultHandler {
}
};
class TestQuery final : public Td::ResultHandler {
class TestNetworkQuery final : public Td::ResultHandler {
Promise<Unit> promise_;
public:
explicit TestQuery(uint64 request_id) : request_id_(request_id) {
explicit TestNetworkQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
}
void send() {
@ -486,17 +488,14 @@ class TestQuery final : public Td::ResultHandler {
return on_error(id, Status::Error(500, "Fetch failed"));
}
LOG(DEBUG) << "TestOK: " << to_string(result_ptr.ok());
send_closure(G()->td(), &Td::send_result, request_id_, make_tl_object<td_api::ok>());
LOG(DEBUG) << "TestNetwork OK: " << to_string(result_ptr.ok());
promise_.set_value(Unit());
}
void on_error(uint64 id, Status status) final {
status.ignore();
LOG(ERROR) << "Test query failed: " << status;
promise_.set_error(std::move(status));
}
private:
uint64 request_id_;
};
class TestProxyRequest final : public RequestOnceActor {
@ -987,7 +986,7 @@ class GetMessageRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "GetMessageRequest"));
}
public:
@ -1008,7 +1007,7 @@ class GetRepliedMessageRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(replied_message_id_));
send_result(td->messages_manager_->get_message_object(replied_message_id_, "GetRepliedMessageRequest"));
}
public:
@ -1056,7 +1055,8 @@ class GetChatPinnedMessageRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object({dialog_id_, pinned_message_id_}));
send_result(
td->messages_manager_->get_message_object({dialog_id_, pinned_message_id_}, "GetChatPinnedMessageRequest"));
}
public:
@ -1076,7 +1076,7 @@ class GetCallbackQueryMessageRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object({dialog_id_, message_id_}));
send_result(td->messages_manager_->get_message_object({dialog_id_, message_id_}, "GetCallbackQueryMessageRequest"));
}
public:
@ -1098,7 +1098,7 @@ class GetMessagesRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(-1, dialog_id_, message_ids_, false));
send_result(td->messages_manager_->get_messages_object(-1, dialog_id_, message_ids_, false, "GetMessagesRequest"));
}
public:
@ -1170,7 +1170,7 @@ class EditMessageTextRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "EditMessageTextRequest"));
}
public:
@ -1197,7 +1197,7 @@ class EditMessageLiveLocationRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "EditMessageLiveLocationRequest"));
}
public:
@ -1224,7 +1224,7 @@ class EditMessageMediaRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "EditMessageMediaRequest"));
}
public:
@ -1249,7 +1249,7 @@ class EditMessageCaptionRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "EditMessageCaptionRequest"));
}
public:
@ -1272,7 +1272,7 @@ class EditMessageReplyMarkupRequest final : public RequestOnceActor {
}
void do_send_result() final {
send_result(td->messages_manager_->get_message_object(full_message_id_));
send_result(td->messages_manager_->get_message_object(full_message_id_, "EditMessageReplyMarkupRequest"));
}
public:
@ -1333,7 +1333,8 @@ class GetMessageThreadHistoryRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(-1, messages_.first, messages_.second, true));
send_result(td->messages_manager_->get_messages_object(-1, messages_.first, messages_.second, true,
"GetMessageThreadHistoryRequest"));
}
public:
@ -1370,7 +1371,8 @@ class SearchChatMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(messages_.first, dialog_id_, messages_.second, true));
send_result(td->messages_manager_->get_messages_object(messages_.first, dialog_id_, messages_.second, true,
"SearchChatMessagesRequest"));
}
void do_send_error(Status &&status) final {
@ -1416,7 +1418,7 @@ class SearchSecretMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_found_messages_object(found_messages_));
send_result(td->messages_manager_->get_found_messages_object(found_messages_, "SearchSecretMessagesRequest"));
}
public:
@ -1454,7 +1456,8 @@ class SearchMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(messages_.first, messages_.second, true));
send_result(
td->messages_manager_->get_messages_object(messages_.first, messages_.second, true, "SearchMessagesRequest"));
}
void do_send_error(Status &&status) final {
@ -1499,7 +1502,8 @@ class SearchCallMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(messages_.first, messages_.second, true));
send_result(td->messages_manager_->get_messages_object(messages_.first, messages_.second, true,
"SearchCallMessagesRequest"));
}
public:
@ -1526,7 +1530,8 @@ class SearchChatRecentLocationMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(messages_.first, dialog_id_, messages_.second, true));
send_result(td->messages_manager_->get_messages_object(messages_.first, dialog_id_, messages_.second, true,
"SearchChatRecentLocationMessagesRequest"));
}
public:
@ -1543,7 +1548,8 @@ class GetActiveLiveLocationMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(-1, full_message_ids_, true));
send_result(td->messages_manager_->get_messages_object(-1, full_message_ids_, true,
"GetActiveLiveLocationMessagesRequest"));
}
public:
@ -1572,34 +1578,6 @@ class GetChatMessageByDateRequest final : public RequestOnceActor {
}
};
class GetChatMessageCountRequest final : public RequestActor<> {
DialogId dialog_id_;
MessageSearchFilter filter_;
bool return_local_;
int64 random_id_;
int32 result_ = 0;
void do_run(Promise<Unit> &&promise) final {
result_ = td->messages_manager_->get_dialog_message_count(dialog_id_, filter_, return_local_, random_id_,
std::move(promise));
}
void do_send_result() final {
send_result(td_api::make_object<td_api::count>(result_));
}
public:
GetChatMessageCountRequest(ActorShared<Td> td, uint64 request_id, int64 dialog_id,
tl_object_ptr<td_api::SearchMessagesFilter> filter, bool return_local)
: RequestActor(std::move(td), request_id)
, dialog_id_(dialog_id)
, filter_(get_message_search_filter(filter))
, return_local_(return_local)
, random_id_(0) {
}
};
class GetChatScheduledMessagesRequest final : public RequestActor<> {
DialogId dialog_id_;
@ -1611,7 +1589,8 @@ class GetChatScheduledMessagesRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td->messages_manager_->get_messages_object(-1, dialog_id_, message_ids_, true));
send_result(td->messages_manager_->get_messages_object(-1, dialog_id_, message_ids_, true,
"GetChatScheduledMessagesRequest"));
}
public:
@ -3268,30 +3247,19 @@ td_api::object_ptr<td_api::Object> Td::static_request(td_api::object_ptr<td_api:
}
void Td::add_handler(uint64 id, std::shared_ptr<ResultHandler> handler) {
result_handlers_.emplace_back(id, handler);
result_handlers_[id] = std::move(handler);
}
std::shared_ptr<Td::ResultHandler> Td::extract_handler(uint64 id) {
std::shared_ptr<Td::ResultHandler> result;
for (size_t i = 0; i < result_handlers_.size(); i++) {
if (result_handlers_[i].first == id) {
result = std::move(result_handlers_[i].second);
result_handlers_.erase(result_handlers_.begin() + i);
break;
}
auto it = result_handlers_.find(id);
if (it == result_handlers_.end()) {
return nullptr;
}
auto result = std::move(it->second);
result_handlers_.erase(it);
return result;
}
void Td::invalidate_handler(ResultHandler *handler) {
for (size_t i = 0; i < result_handlers_.size(); i++) {
if (result_handlers_[i].second.get() == handler) {
result_handlers_.erase(result_handlers_.begin() + i);
i--;
}
}
}
void Td::send(NetQueryPtr &&query) {
VLOG(net_query) << "Send " << query << " to dispatcher";
query->debug("Td: send to NetQueryDispatcher");
@ -3655,10 +3623,6 @@ void Td::dec_request_actor_refcnt() {
}
}
void Td::clear_handlers() {
result_handlers_.clear();
}
void Td::clear_requests() {
while (!pending_alarms_.empty()) {
auto it = pending_alarms_.begin();
@ -3702,7 +3666,7 @@ void Td::clear() {
LOG(DEBUG) << "Options was cleared" << timer;
G()->net_query_creator().stop_check();
clear_handlers();
result_handlers_.clear();
LOG(DEBUG) << "Handlers was cleared" << timer;
G()->net_query_dispatcher().stop();
LOG(DEBUG) << "NetQueryDispatcher was stopped" << timer;
@ -4946,7 +4910,8 @@ void Td::on_request(uint64 id, const td_api::getMessage &request) {
void Td::on_request(uint64 id, const td_api::getMessageLocally &request) {
FullMessageId full_message_id(DialogId(request.chat_id_), MessageId(request.message_id_));
send_closure(actor_id(this), &Td::send_result, id, messages_manager_->get_message_object(full_message_id));
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_message_object(full_message_id, "getMessageLocally"));
}
void Td::on_request(uint64 id, const td_api::getRepliedMessage &request) {
@ -5484,7 +5449,16 @@ void Td::on_request(uint64 id, const td_api::getChatMessageByDate &request) {
void Td::on_request(uint64 id, td_api::getChatMessageCount &request) {
CHECK_IS_USER();
CREATE_REQUEST(GetChatMessageCountRequest, request.chat_id_, std::move(request.filter_), request.return_local_);
CREATE_REQUEST_PROMISE();
auto query_promise = PromiseCreator::lambda([promise = std::move(promise)](Result<int32> result) mutable {
if (result.is_error()) {
promise.set_error(result.move_as_error());
} else {
promise.set_value(make_tl_object<td_api::count>(result.move_as_ok()));
}
});
messages_manager_->get_dialog_message_count(DialogId(request.chat_id_), get_message_search_filter(request.filter_),
request.return_local_, std::move(query_promise));
}
void Td::on_request(uint64 id, const td_api::getChatScheduledMessages &request) {
@ -5556,7 +5530,7 @@ void Td::on_request(uint64 id, td_api::sendMessageAlbum &request) {
}
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_messages_object(-1, dialog_id, r_message_ids.ok(), false));
messages_manager_->get_messages_object(-1, dialog_id, r_message_ids.ok(), false, "sendMessageAlbum"));
}
void Td::on_request(uint64 id, td_api::sendBotStartMessage &request) {
@ -5572,7 +5546,7 @@ void Td::on_request(uint64 id, td_api::sendBotStartMessage &request) {
CHECK(r_new_message_id.ok().is_valid() || r_new_message_id.ok().is_valid_scheduled());
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}));
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}, "sendBotStartMessage"));
}
void Td::on_request(uint64 id, td_api::sendInlineQueryResultMessage &request) {
@ -5588,8 +5562,9 @@ void Td::on_request(uint64 id, td_api::sendInlineQueryResultMessage &request) {
}
CHECK(r_new_message_id.ok().is_valid() || r_new_message_id.ok().is_valid_scheduled());
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}));
send_closure(
actor_id(this), &Td::send_result, id,
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}, "sendInlineQueryResultMessage"));
}
void Td::on_request(uint64 id, td_api::addLocalMessage &request) {
@ -5605,7 +5580,7 @@ void Td::on_request(uint64 id, td_api::addLocalMessage &request) {
CHECK(r_new_message_id.ok().is_valid());
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}));
messages_manager_->get_message_object({dialog_id, r_new_message_id.ok()}, "addLocalMessage"));
}
void Td::on_request(uint64 id, td_api::editMessageText &request) {
@ -5754,7 +5729,7 @@ void Td::on_request(uint64 id, const td_api::resendMessages &request) {
}
send_closure(actor_id(this), &Td::send_result, id,
messages_manager_->get_messages_object(-1, dialog_id, r_message_ids.ok(), false));
messages_manager_->get_messages_object(-1, dialog_id, r_message_ids.ok(), false, "resendMessages"));
}
void Td::on_request(uint64 id, td_api::getWebPagePreview &request) {
@ -8516,7 +8491,8 @@ td_api::object_ptr<td_api::Object> Td::do_static_request(td_api::testReturnError
// test
void Td::on_request(uint64 id, const td_api::testNetwork &request) {
create_handler<TestQuery>(id)->send();
CREATE_OK_REQUEST_PROMISE();
create_handler<TestNetworkQuery>(std::move(promise))->send();
}
void Td::on_request(uint64 id, td_api::testProxy &request) {

6
td/telegram/Td.h
View File

@ -300,7 +300,7 @@ class Td final : public Actor {
enum class State : int32 { WaitParameters, Decrypt, Run, Close } state_ = State::WaitParameters;
bool is_database_encrypted_ = false;
vector<std::pair<uint64, std::shared_ptr<ResultHandler>>> result_handlers_;
std::unordered_map<uint64, std::shared_ptr<ResultHandler>> result_handlers_;
enum : int8 { RequestActorIdType = 1, ActorIdType = 2 };
Container<ActorOwn<Actor>> request_actors_;
@ -341,15 +341,11 @@ class Td final : public Actor {
template <class T>
friend class RequestActor; // uses send_result/send_error
friend class TestQuery; // uses send_result/send_error, TODO pass Promise<>
friend class AuthManager; // uses send_result/send_error, TODO pass Promise<>
friend class PhoneNumberManager; // uses send_result/send_error, TODO pass Promise<>
void add_handler(uint64 id, std::shared_ptr<ResultHandler> handler);
std::shared_ptr<ResultHandler> extract_handler(uint64 id);
void invalidate_handler(ResultHandler *handler);
void clear_handlers();
// void destroy_handler(ResultHandler *handler);
void clear_requests();