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

Explicitly pass Td to Location constructor and don't register locations for bots.

Browse Source
This commit is contained in:
levlam 2023-06-28 19:01:00 +03:00
parent 40d11e7935
commit 3a3ae9eabf
12 changed files with 51 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
td/telegram/ContactsManager.cpp
View File

@ -13117,7 +13117,7 @@ void ContactsManager::on_get_chat_full(tl_object_ptr<telegram_api::ChatFull> &&c
}
on_update_channel_full_linked_channel_id(channel_full, channel_id, linked_channel_id);
on_update_channel_full_location(channel_full, channel_id, DialogLocation(std::move(channel->location_)));
on_update_channel_full_location(channel_full, channel_id, DialogLocation(td_, std::move(channel->location_)));
if (c->is_megagroup) {
on_update_channel_full_slow_mode_delay(channel_full, channel_id, channel->slowmode_seconds_,

4
td/telegram/DialogEventLog.cpp
View File

@ -249,8 +249,8 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
}
case telegram_api::channelAdminLogEventActionChangeLocation::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionChangeLocation>(action_ptr);
auto old_location = DialogLocation(std::move(action->prev_value_));
auto new_location = DialogLocation(std::move(action->new_value_));
auto old_location = DialogLocation(td, std::move(action->prev_value_));
auto new_location = DialogLocation(td, std::move(action->new_value_));
return td_api::make_object<td_api::chatEventLocationChanged>(old_location.get_chat_location_object(),
new_location.get_chat_location_object());
}

4
td/telegram/DialogLocation.cpp
View File

@ -10,10 +10,10 @@
namespace td {
DialogLocation::DialogLocation(telegram_api::object_ptr<telegram_api::ChannelLocation> &&channel_location_ptr) {
DialogLocation::DialogLocation(Td *td, telegram_api::object_ptr<telegram_api::ChannelLocation> &&channel_location_ptr) {
if (channel_location_ptr != nullptr && channel_location_ptr->get_id() == telegram_api::channelLocation::ID) {
auto channel_location = static_cast<telegram_api::channelLocation *>(channel_location_ptr.get());
location_ = Location(channel_location->geo_point_);
location_ = Location(td, channel_location->geo_point_);
address_ = std::move(channel_location->address_);
}
}

4
td/telegram/DialogLocation.h
View File

@ -16,6 +16,8 @@
namespace td {
class Td;
class DialogLocation {
Location location_;
string address_;
@ -28,7 +30,7 @@ class DialogLocation {
public:
DialogLocation() = default;
explicit DialogLocation(telegram_api::object_ptr<telegram_api::ChannelLocation> &&channel_location_ptr);
DialogLocation(Td *td, telegram_api::object_ptr<telegram_api::ChannelLocation> &&channel_location_ptr);
explicit DialogLocation(td_api::object_ptr<td_api::chatLocation> &&chat_location);

11
td/telegram/InlineQueriesManager.cpp
View File

@ -1778,11 +1778,11 @@ void InlineQueriesManager::on_get_inline_query_results(DialogId dialog_id, UserI
if (result->send_message_->get_id() == telegram_api::botInlineMessageMediaGeo::ID) {
auto inline_message_geo =
static_cast<const telegram_api::botInlineMessageMediaGeo *>(result->send_message_.get());
Location l(inline_message_geo->geo_);
Location l(td_, inline_message_geo->geo_);
location->location_ = l.get_location_object();
} else {
auto latitude_longitude = split(Slice(result->description_));
Location l(to_double(latitude_longitude.first), to_double(latitude_longitude.second), 0.0, 0);
Location l(td_, to_double(latitude_longitude.first), to_double(latitude_longitude.second), 0.0, 0);
location->location_ = l.get_location_object();
}
location->thumbnail_ = register_thumbnail(std::move(result->thumb_));
@ -1798,18 +1798,19 @@ void InlineQueriesManager::on_get_inline_query_results(DialogId dialog_id, UserI
if (result->send_message_->get_id() == telegram_api::botInlineMessageMediaVenue::ID) {
auto inline_message_venue =
static_cast<const telegram_api::botInlineMessageMediaVenue *>(result->send_message_.get());
Venue v(inline_message_venue->geo_, inline_message_venue->title_, inline_message_venue->address_,
Venue v(td_, inline_message_venue->geo_, inline_message_venue->title_, inline_message_venue->address_,
inline_message_venue->provider_, inline_message_venue->venue_id_,
inline_message_venue->venue_type_);
venue->venue_ = v.get_venue_object();
} else if (result->send_message_->get_id() == telegram_api::botInlineMessageMediaGeo::ID) {
auto inline_message_geo =
static_cast<const telegram_api::botInlineMessageMediaGeo *>(result->send_message_.get());
Venue v(inline_message_geo->geo_, std::move(result->title_), std::move(result->description_), string(),
Venue v(td_, inline_message_geo->geo_, std::move(result->title_), std::move(result->description_), string(),
string(), string());
venue->venue_ = v.get_venue_object();
} else {
Venue v(nullptr, std::move(result->title_), std::move(result->description_), string(), string(), string());
Venue v(td_, nullptr, std::move(result->title_), std::move(result->description_), string(), string(),
string());
venue->venue_ = v.get_venue_object();
}
venue->thumbnail_ = register_thumbnail(std::move(result->thumb_));

19
td/telegram/Location.cpp
View File

@ -6,6 +6,9 @@
//
#include "td/telegram/Location.h"
#include "td/telegram/AuthManager.h"
#include "td/telegram/Td.h"
#include <cmath>
namespace td {
@ -20,26 +23,28 @@ double Location::fix_accuracy(double accuracy) {
return accuracy;
}
void Location::init(double latitude, double longitude, double horizontal_accuracy, int64 access_hash) {
void Location::init(Td *td, double latitude, double longitude, double horizontal_accuracy, int64 access_hash) {
if (std::isfinite(latitude) && std::isfinite(longitude) && std::abs(latitude) <= 90 && std::abs(longitude) <= 180) {
is_empty_ = false;
latitude_ = latitude;
longitude_ = longitude;
horizontal_accuracy_ = fix_accuracy(horizontal_accuracy);
access_hash_ = access_hash;
if (td != nullptr && !td->auth_manager_->is_bot()) {
G()->add_location_access_hash(latitude_, longitude_, access_hash_);
}
}
}
Location::Location(double latitude, double longitude, double horizontal_accuracy, int64 access_hash) {
init(latitude, longitude, horizontal_accuracy, access_hash);
Location::Location(Td *td, double latitude, double longitude, double horizontal_accuracy, int64 access_hash) {
init(td, latitude, longitude, horizontal_accuracy, access_hash);
}
Location::Location(const tl_object_ptr<secret_api::decryptedMessageMediaGeoPoint> &geo_point)
: Location(geo_point->lat_, geo_point->long_, 0.0, 0) {
: Location(nullptr, geo_point->lat_, geo_point->long_, 0.0, 0) {
}
Location::Location(const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr) {
Location::Location(Td *td, const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr) {
if (geo_point_ptr == nullptr) {
return;
}
@ -48,7 +53,7 @@ Location::Location(const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr) {
break;
case telegram_api::geoPoint::ID: {
auto geo_point = static_cast<const telegram_api::geoPoint *>(geo_point_ptr.get());
init(geo_point->lat_, geo_point->long_, geo_point->accuracy_radius_, geo_point->access_hash_);
init(td, geo_point->lat_, geo_point->long_, geo_point->accuracy_radius_, geo_point->access_hash_);
break;
}
default:
@ -62,7 +67,7 @@ Location::Location(const tl_object_ptr<td_api::location> &location) {
return;
}
init(location->latitude_, location->longitude_, location->horizontal_accuracy_, 0);
init(nullptr, location->latitude_, location->longitude_, location->horizontal_accuracy_, 0);
}
bool Location::empty() const {

8
td/telegram/Location.h
View File

@ -19,6 +19,8 @@
namespace td {
class Td;
class Location {
bool is_empty_ = true;
double latitude_ = 0.0;
@ -31,18 +33,18 @@ class Location {
friend StringBuilder &operator<<(StringBuilder &string_builder, const Location &location);
void init(double latitude, double longitude, double horizontal_accuracy, int64 access_hash);
void init(Td *td, double latitude, double longitude, double horizontal_accuracy, int64 access_hash);
static double fix_accuracy(double accuracy);
public:
Location() = default;
Location(double latitude, double longitude, double horizontal_accuracy, int64 access_hash);
Location(Td *td, double latitude, double longitude, double horizontal_accuracy, int64 access_hash);
explicit Location(const tl_object_ptr<secret_api::decryptedMessageMediaGeoPoint> &geo_point);
explicit Location(const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr);
Location(Td *td, const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr);
explicit Location(const tl_object_ptr<td_api::location> &location);

18
td/telegram/MessageContent.cpp
View File

@ -1934,10 +1934,10 @@ InlineMessageContent create_inline_message_content(Td *td, FileId file_id,
auto inline_message = move_tl_object_as<telegram_api::botInlineMessageMediaGeo>(bot_inline_message);
if (inline_message->period_ > 0) {
result.message_content =
make_unique<MessageLiveLocation>(Location(inline_message->geo_), inline_message->period_,
make_unique<MessageLiveLocation>(Location(td, inline_message->geo_), inline_message->period_,
inline_message->heading_, inline_message->proximity_notification_radius_);
} else {
result.message_content = make_unique<MessageLocation>(Location(inline_message->geo_));
result.message_content = make_unique<MessageLocation>(Location(td, inline_message->geo_));
}
reply_markup = std::move(inline_message->reply_markup_);
break;
@ -1945,7 +1945,7 @@ InlineMessageContent create_inline_message_content(Td *td, FileId file_id,
case telegram_api::botInlineMessageMediaVenue::ID: {
auto inline_message = move_tl_object_as<telegram_api::botInlineMessageMediaVenue>(bot_inline_message);
result.message_content = make_unique<MessageVenue>(
Venue(inline_message->geo_, std::move(inline_message->title_), std::move(inline_message->address_),
Venue(td, inline_message->geo_, std::move(inline_message->title_), std::move(inline_message->address_),
std::move(inline_message->provider_), std::move(inline_message->venue_id_),
std::move(inline_message->venue_type_)));
reply_markup = std::move(inline_message->reply_markup_);
@ -4749,9 +4749,9 @@ unique_ptr<MessageContent> get_secret_message_content(
media->venue_id_.clear();
}
auto m = make_unique<MessageVenue>(Venue(Location(media->lat_, media->long_, 0.0, 0), std::move(media->title_),
std::move(media->address_), std::move(media->provider_),
std::move(media->venue_id_), string()));
auto m = make_unique<MessageVenue>(Venue(Location(td, media->lat_, media->long_, 0.0, 0),
std::move(media->title_), std::move(media->address_),
std::move(media->provider_), std::move(media->venue_id_), string()));
if (m->venue.empty()) {
is_media_empty = true;
break;
@ -4907,7 +4907,7 @@ unique_ptr<MessageContent> get_message_content(Td *td, FormattedText message,
case telegram_api::messageMediaGeo::ID: {
auto media = move_tl_object_as<telegram_api::messageMediaGeo>(media_ptr);
auto m = make_unique<MessageLocation>(Location(media->geo_));
auto m = make_unique<MessageLocation>(Location(td, media->geo_));
if (m->location.empty()) {
break;
}
@ -4916,7 +4916,7 @@ unique_ptr<MessageContent> get_message_content(Td *td, FormattedText message,
}
case telegram_api::messageMediaGeoLive::ID: {
auto media = move_tl_object_as<telegram_api::messageMediaGeoLive>(media_ptr);
auto location = Location(media->geo_);
auto location = Location(td, media->geo_);
if (location.empty()) {
break;
}
@ -4931,7 +4931,7 @@ unique_ptr<MessageContent> get_message_content(Td *td, FormattedText message,
}
case telegram_api::messageMediaVenue::ID: {
auto media = move_tl_object_as<telegram_api::messageMediaVenue>(media_ptr);
auto m = make_unique<MessageVenue>(Venue(media->geo_, std::move(media->title_), std::move(media->address_),
auto m = make_unique<MessageVenue>(Venue(td, media->geo_, std::move(media->title_), std::move(media->address_),
std::move(media->provider_), std::move(media->venue_id_),
std::move(media->venue_type_)));
if (m->venue.empty()) {

4
td/telegram/UpdatesManager.cpp
View File

@ -3881,13 +3881,13 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateDcOptions> upda
}
void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotInlineQuery> update, Promise<Unit> &&promise) {
td_->inline_queries_manager_->on_new_query(update->query_id_, UserId(update->user_id_), Location(update->geo_),
td_->inline_queries_manager_->on_new_query(update->query_id_, UserId(update->user_id_), Location(td_, update->geo_),
std::move(update->peer_type_), update->query_, update->offset_);
promise.set_value(Unit());
}
void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotInlineSend> update, Promise<Unit> &&promise) {
td_->inline_queries_manager_->on_chosen_result(UserId(update->user_id_), Location(update->geo_), update->query_,
td_->inline_queries_manager_->on_chosen_result(UserId(update->user_id_), Location(td_, update->geo_), update->query_,
update->id_, std::move(update->msg_id_));
promise.set_value(Unit());
}

6
td/telegram/Venue.cpp
View File

@ -11,9 +11,9 @@
namespace td {
Venue::Venue(const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr, string title, string address, string provider,
string id, string type)
: location_(geo_point_ptr)
Venue::Venue(Td *td, const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr, string title, string address,
string provider, string id, string type)
: location_(td, geo_point_ptr)
, title_(std::move(title))
, address_(std::move(address))
, provider_(std::move(provider))

6
td/telegram/Venue.h
View File

@ -19,6 +19,8 @@
namespace td {
class Td;
class Venue {
Location location_;
string title_;
@ -34,8 +36,8 @@ class Venue {
public:
Venue() = default;
Venue(const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr, string title, string address, string provider,
string id, string type);
Venue(Td *td, const tl_object_ptr<telegram_api::GeoPoint> &geo_point_ptr, string title, string address,
string provider, string id, string type);
Venue(Location location, string title, string address, string provider, string id, string type);

2
td/telegram/WebPageBlock.cpp
View File

@ -2242,7 +2242,7 @@ unique_ptr<WebPageBlock> get_web_page_block(Td *td, tl_object_ptr<telegram_api::
}
case telegram_api::pageBlockMap::ID: {
auto page_block = move_tl_object_as<telegram_api::pageBlockMap>(page_block_ptr);
Location location(page_block->geo_);
Location location(td, page_block->geo_);
auto zoom = page_block->zoom_;
Dimensions dimensions = get_dimensions(page_block->w_, page_block->h_, "pageBlockMap");
if (location.empty()) {