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

Use StickerType instead of is_masks everywhere.

Browse Source
This commit is contained in:
levlam 2022-07-14 16:17:19 +03:00
parent b447c32fe9
commit c34f5d063b
8 changed files with 271 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
td/generate/scheme/td_api.tl
View File

@ -4386,8 +4386,8 @@ updateOption name:string value:OptionValue = Update;
//@description A sticker set has changed @sticker_set The sticker set
updateStickerSet sticker_set:stickerSet = Update;
//@description The list of installed sticker sets was updated @is_masks True, if the list of installed mask sticker sets was updated @sticker_set_ids The new list of installed ordinary sticker sets
updateInstalledStickerSets is_masks:Bool sticker_set_ids:vector<int64> = Update;
//@description The list of installed sticker sets was updated @sticker_type Type of the affected stickers @sticker_set_ids The new list of installed ordinary sticker sets
updateInstalledStickerSets sticker_type:StickerType sticker_set_ids:vector<int64> = Update;
//@description The list of trending sticker sets was updated or some of them were viewed @sticker_sets The prefix of the list of trending sticker sets with the newest trending sticker sets
updateTrendingStickerSets sticker_sets:trendingStickerSets = Update;
@ -5887,11 +5887,11 @@ getStickers emoji:string limit:int32 = Stickers;
//@description Searches for stickers from public sticker sets that correspond to a given emoji @emoji String representation of emoji; must be non-empty @limit The maximum number of stickers to be returned
searchStickers emoji:string limit:int32 = Stickers;
//@description Returns a list of installed sticker sets @is_masks Pass true to return mask sticker sets; pass false to return ordinary sticker sets
getInstalledStickerSets is_masks:Bool = StickerSets;
//@description Returns a list of installed sticker sets @sticker_type Type of the sticker sets to return
getInstalledStickerSets sticker_type:StickerType = StickerSets;
//@description Returns a list of archived sticker sets @is_masks Pass true to return mask stickers sets; pass false to return ordinary sticker sets @offset_sticker_set_id Identifier of the sticker set from which to return the result @limit The maximum number of sticker sets to return; up to 100
getArchivedStickerSets is_masks:Bool offset_sticker_set_id:int64 limit:int32 = StickerSets;
//@description Returns a list of archived sticker sets @sticker_type Type of the sticker sets to return @offset_sticker_set_id Identifier of the sticker set from which to return the result @limit The maximum number of sticker sets to return; up to 100
getArchivedStickerSets sticker_type:StickerType offset_sticker_set_id:int64 limit:int32 = StickerSets;
//@description Returns a list of trending sticker sets. For optimal performance, the number of returned sticker sets is chosen by TDLib
//@offset The offset from which to return the sticker sets; must be non-negative
@ -5907,8 +5907,8 @@ getStickerSet set_id:int64 = StickerSet;
//@description Searches for a sticker set by its name @name Name of the sticker set
searchStickerSet name:string = StickerSet;
//@description Searches for installed sticker sets by looking for specified query in their title and name @is_masks Pass true to return mask sticker sets; pass false to return ordinary sticker sets @query Query to search for @limit The maximum number of sticker sets to return
searchInstalledStickerSets is_masks:Bool query:string limit:int32 = StickerSets;
//@description Searches for installed sticker sets by looking for specified query in their title and name @sticker_type Type of the sticker sets to search for @query Query to search for @limit The maximum number of sticker sets to return
searchInstalledStickerSets sticker_type:StickerType query:string limit:int32 = StickerSets;
//@description Searches for ordinary sticker sets by looking for specified query in their title and name. Excludes installed sticker sets from the results @query Query to search for
searchStickerSets query:string = StickerSets;
@ -5919,8 +5919,8 @@ changeStickerSet set_id:int64 is_installed:Bool is_archived:Bool = Ok;
//@description Informs the server that some trending sticker sets have been viewed by the user @sticker_set_ids Identifiers of viewed trending sticker sets
viewTrendingStickerSets sticker_set_ids:vector<int64> = Ok;
//@description Changes the order of installed sticker sets @is_masks Pass true to change the order of mask sticker sets; pass false to change the order of ordinary sticker sets @sticker_set_ids Identifiers of installed sticker sets in the new correct order
reorderInstalledStickerSets is_masks:Bool sticker_set_ids:vector<int64> = Ok;
//@description Changes the order of installed sticker sets @sticker_type Type of the sticker sets to reorder @sticker_set_ids Identifiers of installed sticker sets in the new correct order
reorderInstalledStickerSets sticker_type:StickerType sticker_set_ids:vector<int64> = Ok;
//@description Returns a list of recently used stickers @is_attached Pass true to return stickers and masks that were recently attached to photos or video files; pass false to return recently sent stickers
getRecentStickers is_attached:Bool = Stickers;

2
td/telegram/StickerType.h
View File

@ -16,6 +16,8 @@ namespace td {
// update store_sticker/store_sticker_set when this type changes
enum class StickerType : int32 { Regular, Mask };
static constexpr int32 MAX_STICKER_TYPE = 2;
StickerType get_sticker_type(const td_api::object_ptr<td_api::StickerType> &type);
td_api::object_ptr<td_api::StickerType> get_sticker_type_object(StickerType sticker_type);

341
td/telegram/StickersManager.cpp
View File

@ -92,12 +92,12 @@ class GetAvailableReactionsQuery final : public Td::ResultHandler {
};
class GetAllStickersQuery final : public Td::ResultHandler {
bool is_masks_;
StickerType sticker_type_;
public:
void send(bool is_masks, int64 hash) {
is_masks_ = is_masks;
if (is_masks) {
void send(StickerType sticker_type, int64 hash) {
sticker_type_ = sticker_type;
if (sticker_type == StickerType::Mask) {
send_query(G()->net_query_creator().create(telegram_api::messages_getMaskStickers(hash)));
} else {
send_query(G()->net_query_creator().create(telegram_api::messages_getAllStickers(hash)));
@ -114,15 +114,15 @@ class GetAllStickersQuery final : public Td::ResultHandler {
}
auto ptr = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for get all " << (is_masks_ ? "masks" : "stickers") << ": " << to_string(ptr);
td_->stickers_manager_->on_get_installed_sticker_sets(is_masks_, std::move(ptr));
LOG(DEBUG) << "Receive result for get all " << sticker_type_ << " stickers: " << to_string(ptr);
td_->stickers_manager_->on_get_installed_sticker_sets(sticker_type_, std::move(ptr));
}
void on_error(Status status) final {
if (!G()->is_expected_error(status)) {
LOG(ERROR) << "Receive error for get all stickers: " << status;
}
td_->stickers_manager_->on_get_installed_sticker_sets_failed(is_masks_, std::move(status));
td_->stickers_manager_->on_get_installed_sticker_sets_failed(sticker_type_, std::move(status));
}
};
@ -264,18 +264,18 @@ class GetEmojiUrlQuery final : public Td::ResultHandler {
class GetArchivedStickerSetsQuery final : public Td::ResultHandler {
Promise<Unit> promise_;
StickerSetId offset_sticker_set_id_;
bool is_masks_;
StickerType sticker_type_;
public:
explicit GetArchivedStickerSetsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
}
void send(bool is_masks, StickerSetId offset_sticker_set_id, int32 limit) {
void send(StickerType sticker_type, StickerSetId offset_sticker_set_id, int32 limit) {
offset_sticker_set_id_ = offset_sticker_set_id;
is_masks_ = is_masks;
sticker_type_ = sticker_type;
int32 flags = 0;
if (is_masks_) {
if (sticker_type_ == StickerType::Mask) {
flags |= telegram_api::messages_getArchivedStickers::MASKS_MASK;
}
send_query(G()->net_query_creator().create(telegram_api::messages_getArchivedStickers(
@ -290,7 +290,7 @@ class GetArchivedStickerSetsQuery final : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for GetArchivedStickerSetsQuery: " << to_string(ptr);
td_->stickers_manager_->on_get_archived_sticker_sets(is_masks_, offset_sticker_set_id_, std::move(ptr->sets_),
td_->stickers_manager_->on_get_archived_sticker_sets(sticker_type_, offset_sticker_set_id_, std::move(ptr->sets_),
ptr->count_);
promise_.set_value(Unit());
@ -640,13 +640,13 @@ class FaveStickerQuery final : public Td::ResultHandler {
};
class ReorderStickerSetsQuery final : public Td::ResultHandler {
bool is_masks_;
StickerType sticker_type_;
public:
void send(bool is_masks, const vector<StickerSetId> &sticker_set_ids) {
is_masks_ = is_masks;
void send(StickerType sticker_type, const vector<StickerSetId> &sticker_set_ids) {
sticker_type_ = sticker_type;
int32 flags = 0;
if (is_masks) {
if (sticker_type == StickerType::Mask) {
flags |= telegram_api::messages_reorderStickerSets::MASKS_MASK;
}
send_query(G()->net_query_creator().create(telegram_api::messages_reorderStickerSets(
@ -669,7 +669,7 @@ class ReorderStickerSetsQuery final : public Td::ResultHandler {
if (!G()->is_expected_error(status)) {
LOG(ERROR) << "Receive error for ReorderStickerSetsQuery: " << status;
}
td_->stickers_manager_->reload_installed_sticker_sets(is_masks_, true);
td_->stickers_manager_->reload_installed_sticker_sets(sticker_type_, true);
}
};
@ -1000,12 +1000,12 @@ class CreateNewStickerSetQuery final : public Td::ResultHandler {
}
void send(tl_object_ptr<telegram_api::InputUser> &&input_user, const string &title, const string &short_name,
bool is_masks, StickerFormat sticker_format,
StickerType sticker_type, StickerFormat sticker_format,
vector<tl_object_ptr<telegram_api::inputStickerSetItem>> &&input_stickers, const string &software) {
CHECK(input_user != nullptr);
int32 flags = 0;
if (is_masks) {
if (sticker_type == StickerType::Mask) {
flags |= telegram_api::stickers_createStickerSet::MASKS_MASK;
}
if (sticker_format == StickerFormat::Tgs) {
@ -2035,9 +2035,8 @@ tl_object_ptr<td_api::stickerSet> StickersManager::get_sticker_set_object(Sticke
get_sticker_minithumbnail(sticker_set->minithumbnail, sticker_set->id, -2,
get_sticker_set_minithumbnail_zoom(sticker_set)),
sticker_set->is_installed && !sticker_set->is_archived, sticker_set->is_archived, sticker_set->is_official,
get_sticker_format_object(sticker_set->sticker_format),
get_sticker_type_object(sticker_set->is_masks ? StickerType::Mask : StickerType::Regular), sticker_set->is_viewed,
std::move(stickers), std::move(emojis));
get_sticker_format_object(sticker_set->sticker_format), get_sticker_type_object(sticker_set->sticker_type),
sticker_set->is_viewed, std::move(stickers), std::move(emojis));
}
tl_object_ptr<td_api::stickerSets> StickersManager::get_sticker_sets_object(int32 total_count,
@ -2110,9 +2109,9 @@ tl_object_ptr<td_api::stickerSetInfo> StickersManager::get_sticker_set_info_obje
get_sticker_minithumbnail(sticker_set->minithumbnail, sticker_set->id, -3,
get_sticker_set_minithumbnail_zoom(sticker_set)),
sticker_set->is_installed && !sticker_set->is_archived, sticker_set->is_archived, sticker_set->is_official,
get_sticker_format_object(sticker_set->sticker_format),
get_sticker_type_object(sticker_set->is_masks ? StickerType::Mask : StickerType::Regular), sticker_set->is_viewed,
sticker_set->was_loaded ? actual_count : max(actual_count, sticker_set->sticker_count), std::move(stickers));
get_sticker_format_object(sticker_set->sticker_format), get_sticker_type_object(sticker_set->sticker_type),
sticker_set->is_viewed, sticker_set->was_loaded ? actual_count : max(actual_count, sticker_set->sticker_count),
std::move(stickers));
}
const StickersManager::StickerSet *StickersManager::get_animated_emoji_sticker_set() {
@ -2581,16 +2580,17 @@ tl_object_ptr<telegram_api::InputStickerSet> StickersManager::get_input_sticker_
return make_tl_object<telegram_api::inputStickerSetID>(set->id.get(), set->access_hash);
}
void StickersManager::reload_installed_sticker_sets(bool is_masks, bool force) {
void StickersManager::reload_installed_sticker_sets(StickerType sticker_type, bool force) {
if (G()->close_flag()) {
return;
}
auto &next_load_time = next_installed_sticker_sets_load_time_[is_masks];
auto &next_load_time = next_installed_sticker_sets_load_time_[static_cast<int32>(sticker_type)];
if (!td_->auth_manager_->is_bot() && next_load_time >= 0 && (next_load_time < Time::now() || force)) {
LOG_IF(INFO, force) << "Reload sticker sets";
next_load_time = -1;
td_->create_handler<GetAllStickersQuery>()->send(is_masks, installed_sticker_sets_hash_[is_masks]);
td_->create_handler<GetAllStickersQuery>()->send(sticker_type,
installed_sticker_sets_hash_[static_cast<int32>(sticker_type)]);
}
}
@ -2923,7 +2923,7 @@ StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr<telegram_api::sti
bool is_official = set->official_;
StickerFormat sticker_format =
set->videos_ ? StickerFormat::Webm : (set->animated_ ? StickerFormat::Tgs : StickerFormat::Webp);
bool is_masks = set->masks_;
StickerType sticker_type = set->masks_ ? StickerType::Mask : StickerType::Regular;
PhotoSize thumbnail;
string minithumbnail;
@ -2956,7 +2956,7 @@ StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr<telegram_api::sti
s->hash = set->hash_;
s->is_official = is_official;
s->sticker_format = sticker_format;
s->is_masks = is_masks;
s->sticker_type = sticker_type;
s->is_changed = true;
} else {
CHECK(s->id == set_id);
@ -2970,8 +2970,9 @@ StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr<telegram_api::sti
s->title = std::move(set->title_);
s->is_changed = true;
if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id.get())) {
installed_sticker_sets_hints_[s->is_masks].add(set_id.get(), PSLICE() << s->title << ' ' << s->short_name);
if (installed_sticker_sets_hints_[static_cast<int32>(s->sticker_type)].has_key(set_id.get())) {
installed_sticker_sets_hints_[static_cast<int32>(s->sticker_type)].add(
set_id.get(), PSLICE() << s->title << ' ' << s->short_name);
}
}
if (s->short_name != set->short_name_) {
@ -2981,8 +2982,9 @@ StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr<telegram_api::sti
s->short_name = std::move(set->short_name_);
s->is_changed = true;
if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id.get())) {
installed_sticker_sets_hints_[s->is_masks].add(set_id.get(), PSLICE() << s->title << ' ' << s->short_name);
if (installed_sticker_sets_hints_[static_cast<int32>(s->sticker_type)].has_key(set_id.get())) {
installed_sticker_sets_hints_[static_cast<int32>(s->sticker_type)].add(
set_id.get(), PSLICE() << s->title << ' ' << s->short_name);
}
}
if (s->minithumbnail != minithumbnail) {
@ -3026,8 +3028,9 @@ StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr<telegram_api::sti
s->sticker_format = sticker_format;
s->is_changed = true;
}
LOG_IF(ERROR, s->is_masks != is_masks) << "Masks type of " << set_id << "/" << s->short_name << " has changed from "
<< s->is_masks << " to " << is_masks << " from " << source;
LOG_IF(ERROR, s->sticker_type != sticker_type)
<< "Type of " << set_id << "/" << s->short_name << " has changed from " << s->sticker_type << " to "
<< sticker_type << " from " << source;
}
auto cleaned_username = clean_username(s->short_name);
if (!cleaned_username.empty()) {
@ -3406,21 +3409,22 @@ void StickersManager::on_get_available_reactions(
update_active_reactions();
}
void StickersManager::on_get_installed_sticker_sets(bool is_masks,
void StickersManager::on_get_installed_sticker_sets(StickerType sticker_type,
tl_object_ptr<telegram_api::messages_AllStickers> &&stickers_ptr) {
next_installed_sticker_sets_load_time_[is_masks] = Time::now_cached() + Random::fast(30 * 60, 50 * 60);
next_installed_sticker_sets_load_time_[static_cast<int32>(sticker_type)] =
Time::now_cached() + Random::fast(30 * 60, 50 * 60);
CHECK(stickers_ptr != nullptr);
int32 constructor_id = stickers_ptr->get_id();
if (constructor_id == telegram_api::messages_allStickersNotModified::ID) {
LOG(INFO) << (is_masks ? "Masks" : "Stickers") << " are not modified";
LOG(INFO) << sticker_type << " stickers are not modified";
return;
}
CHECK(constructor_id == telegram_api::messages_allStickers::ID);
auto stickers = move_tl_object_as<telegram_api::messages_allStickers>(stickers_ptr);
FlatHashSet<StickerSetId, StickerSetIdHash> uninstalled_sticker_sets;
for (auto &sticker_set_id : installed_sticker_set_ids_[is_masks]) {
for (auto &sticker_set_id : installed_sticker_set_ids_[static_cast<int32>(sticker_type)]) {
uninstalled_sticker_sets.insert(sticker_set_id);
}
@ -3441,10 +3445,10 @@ void StickersManager::on_get_installed_sticker_sets(bool is_masks,
CHECK(sticker_set != nullptr);
LOG_IF(ERROR, !sticker_set->is_installed) << "Receive non-installed sticker set in getAllStickers";
LOG_IF(ERROR, sticker_set->is_archived) << "Receive archived sticker set in getAllStickers";
LOG_IF(ERROR, sticker_set->is_masks != is_masks) << "Receive sticker set of a wrong type in getAllStickers";
LOG_IF(ERROR, sticker_set->sticker_type != sticker_type) << "Receive sticker set of a wrong type in getAllStickers";
CHECK(sticker_set->is_inited);
if (sticker_set->is_installed && !sticker_set->is_archived && sticker_set->is_masks == is_masks) {
if (sticker_set->is_installed && !sticker_set->is_archived && sticker_set->sticker_type == sticker_type) {
installed_sticker_set_ids.push_back(set_id);
uninstalled_sticker_sets.erase(set_id);
}
@ -3470,22 +3474,23 @@ void StickersManager::on_get_installed_sticker_sets(bool is_masks,
update_sticker_set(sticker_set, "on_get_installed_sticker_sets 2");
}
on_load_installed_sticker_sets_finished(is_masks, std::move(installed_sticker_set_ids));
on_load_installed_sticker_sets_finished(sticker_type, std::move(installed_sticker_set_ids));
if (installed_sticker_sets_hash_[is_masks] != stickers->hash_) {
if (installed_sticker_sets_hash_[static_cast<int32>(sticker_type)] != stickers->hash_) {
LOG(ERROR) << "Sticker sets hash mismatch: server hash list = " << debug_hashes << ", client hash list = "
<< transform(installed_sticker_set_ids_[is_masks],
<< transform(installed_sticker_set_ids_[static_cast<int32>(sticker_type)],
[this](StickerSetId sticker_set_id) { return get_sticker_set(sticker_set_id)->hash; })
<< ", server sticker set list = " << debug_sticker_set_ids
<< ", client sticker set list = " << installed_sticker_set_ids_[is_masks]
<< ", server hash = " << stickers->hash_ << ", client hash = " << installed_sticker_sets_hash_[is_masks];
<< ", client sticker set list = " << installed_sticker_set_ids_[static_cast<int32>(sticker_type)]
<< ", server hash = " << stickers->hash_
<< ", client hash = " << installed_sticker_sets_hash_[static_cast<int32>(sticker_type)];
}
}
void StickersManager::on_get_installed_sticker_sets_failed(bool is_masks, Status error) {
void StickersManager::on_get_installed_sticker_sets_failed(StickerType sticker_type, Status error) {
CHECK(error.is_error());
next_installed_sticker_sets_load_time_[is_masks] = Time::now_cached() + Random::fast(5, 10);
fail_promises(load_installed_sticker_sets_queries_[is_masks], std::move(error));
next_installed_sticker_sets_load_time_[static_cast<int32>(sticker_type)] = Time::now_cached() + Random::fast(5, 10);
fail_promises(load_installed_sticker_sets_queries_[static_cast<int32>(sticker_type)], std::move(error));
}
std::pair<vector<FileId>, vector<FileId>> StickersManager::split_stickers_by_premium(
@ -3511,8 +3516,8 @@ vector<FileId> StickersManager::get_stickers(string emoji, int32 limit, bool for
promise.set_error(Status::Error(400, "Parameter limit must be positive"));
return {};
}
if (!are_installed_sticker_sets_loaded_[0]) {
load_installed_sticker_sets(false, std::move(promise));
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(StickerType::Regular)]) {
load_installed_sticker_sets(StickerType::Regular, std::move(promise));
return {};
}
@ -3536,7 +3541,7 @@ vector<FileId> StickersManager::get_stickers(string emoji, int32 limit, bool for
vector<StickerSetId> sets_to_load;
bool need_load = false;
for (const auto &sticker_set_id : installed_sticker_set_ids_[0]) {
for (const auto &sticker_set_id : installed_sticker_set_ids_[static_cast<int32>(StickerType::Regular)]) {
const StickerSet *sticker_set = get_sticker_set(sticker_set_id);
CHECK(sticker_set != nullptr);
CHECK(sticker_set->is_inited);
@ -3605,7 +3610,7 @@ vector<FileId> StickersManager::get_stickers(string emoji, int32 limit, bool for
vector<FileId> result;
auto limit_size_t = static_cast<size_t>(limit);
if (emoji.empty()) {
for (const auto &sticker_set_id : installed_sticker_set_ids_[0]) {
for (const auto &sticker_set_id : installed_sticker_set_ids_[static_cast<int32>(StickerType::Regular)]) {
const StickerSet *sticker_set = get_sticker_set(sticker_set_id);
if (sticker_set == nullptr || !sticker_set->was_loaded) {
continue;
@ -3619,7 +3624,7 @@ vector<FileId> StickersManager::get_stickers(string emoji, int32 limit, bool for
}
} else {
vector<const StickerSet *> examined_sticker_sets;
for (const auto &sticker_set_id : installed_sticker_set_ids_[0]) {
for (const auto &sticker_set_id : installed_sticker_set_ids_[static_cast<int32>(StickerType::Regular)]) {
const StickerSet *sticker_set = get_sticker_set(sticker_set_id);
if (sticker_set == nullptr || !sticker_set->was_loaded) {
continue;
@ -3844,15 +3849,15 @@ void StickersManager::on_find_stickers_fail(const string &emoji, Status &&error)
fail_promises(promises, std::move(error));
}
vector<StickerSetId> StickersManager::get_installed_sticker_sets(bool is_masks, Promise<Unit> &&promise) {
if (!are_installed_sticker_sets_loaded_[is_masks]) {
load_installed_sticker_sets(is_masks, std::move(promise));
vector<StickerSetId> StickersManager::get_installed_sticker_sets(StickerType sticker_type, Promise<Unit> &&promise) {
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)]) {
load_installed_sticker_sets(sticker_type, std::move(promise));
return {};
}
reload_installed_sticker_sets(is_masks, false);
reload_installed_sticker_sets(sticker_type, false);
promise.set_value(Unit());
return installed_sticker_set_ids_[is_masks];
return installed_sticker_set_ids_[static_cast<int32>(sticker_type)];
}
bool StickersManager::update_sticker_set_cache(const StickerSet *sticker_set, Promise<Unit> &promise) {
@ -3866,7 +3871,7 @@ bool StickersManager::update_sticker_set_cache(const StickerSet *sticker_set, Pr
load_sticker_sets({set_id}, Auto());
}
} else if (sticker_set->is_installed) {
reload_installed_sticker_sets(sticker_set->is_masks, false);
reload_installed_sticker_sets(sticker_set->sticker_type, false);
} else {
if (G()->unix_time() >= sticker_set->expires_at) {
if (td_->auth_manager_->is_bot()) {
@ -3921,10 +3926,10 @@ StickerSetId StickersManager::search_sticker_set(const string &short_name_to_sea
return sticker_set->id;
}
std::pair<int32, vector<StickerSetId>> StickersManager::search_installed_sticker_sets(bool is_masks,
std::pair<int32, vector<StickerSetId>> StickersManager::search_installed_sticker_sets(StickerType sticker_type,
const string &query, int32 limit,
Promise<Unit> &&promise) {
LOG(INFO) << "Search installed " << (is_masks ? "mask " : "") << "sticker sets with query = \"" << query
LOG(INFO) << "Search installed " << sticker_type << " sticker sets with query = \"" << query
<< "\" and limit = " << limit;
if (limit < 0) {
@ -3932,13 +3937,14 @@ std::pair<int32, vector<StickerSetId>> StickersManager::search_installed_sticker
return {};
}
if (!are_installed_sticker_sets_loaded_[is_masks]) {
load_installed_sticker_sets(is_masks, std::move(promise));
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)]) {
load_installed_sticker_sets(sticker_type, std::move(promise));
return {};
}
reload_installed_sticker_sets(is_masks, false);
reload_installed_sticker_sets(sticker_type, false);
std::pair<size_t, vector<int64>> result = installed_sticker_sets_hints_[is_masks].search(query, limit);
std::pair<size_t, vector<int64>> result =
installed_sticker_sets_hints_[static_cast<int32>(sticker_type)].search(query, limit);
promise.set_value(Unit());
return {narrow_cast<int32>(result.first), convert_sticker_set_ids(result.second)};
}
@ -4022,8 +4028,8 @@ void StickersManager::change_sticker_set(StickerSetId set_id, bool is_installed,
load_sticker_sets({set_id}, std::move(promise));
return;
}
if (!are_installed_sticker_sets_loaded_[sticker_set->is_masks]) {
load_installed_sticker_sets(sticker_set->is_masks, std::move(promise));
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_set->sticker_type)]) {
load_installed_sticker_sets(sticker_set->sticker_type, std::move(promise));
return;
}
@ -4068,22 +4074,23 @@ void StickersManager::on_update_sticker_set(StickerSet *sticker_set, bool is_ins
}
bool is_added = sticker_set->is_installed && !sticker_set->is_archived;
auto type = static_cast<int32>(sticker_set->sticker_type);
if (was_added != is_added) {
vector<StickerSetId> &sticker_set_ids = installed_sticker_set_ids_[sticker_set->is_masks];
need_update_installed_sticker_sets_[sticker_set->is_masks] = true;
vector<StickerSetId> &sticker_set_ids = installed_sticker_set_ids_[type];
need_update_installed_sticker_sets_[type] = true;
if (is_added) {
installed_sticker_sets_hints_[sticker_set->is_masks].add(
sticker_set->id.get(), PSLICE() << sticker_set->title << ' ' << sticker_set->short_name);
installed_sticker_sets_hints_[type].add(sticker_set->id.get(),
PSLICE() << sticker_set->title << ' ' << sticker_set->short_name);
sticker_set_ids.insert(sticker_set_ids.begin(), sticker_set->id);
} else {
installed_sticker_sets_hints_[sticker_set->is_masks].remove(sticker_set->id.get());
installed_sticker_sets_hints_[type].remove(sticker_set->id.get());
td::remove(sticker_set_ids, sticker_set->id);
}
}
if (was_archived != is_archived && is_changed) {
int32 &total_count = total_archived_sticker_set_count_[sticker_set->is_masks];
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[sticker_set->is_masks];
int32 &total_count = total_archived_sticker_set_count_[type];
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[type];
if (total_count < 0) {
return;
}
@ -4104,49 +4111,49 @@ void StickersManager::on_update_sticker_set(StickerSet *sticker_set, bool is_ins
}
}
void StickersManager::load_installed_sticker_sets(bool is_masks, Promise<Unit> &&promise) {
void StickersManager::load_installed_sticker_sets(StickerType sticker_type, Promise<Unit> &&promise) {
if (td_->auth_manager_->is_bot()) {
are_installed_sticker_sets_loaded_[is_masks] = true;
are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)] = true;
}
if (are_installed_sticker_sets_loaded_[is_masks]) {
if (are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)]) {
promise.set_value(Unit());
return;
}
load_installed_sticker_sets_queries_[is_masks].push_back(std::move(promise));
if (load_installed_sticker_sets_queries_[is_masks].size() == 1u) {
load_installed_sticker_sets_queries_[static_cast<int32>(sticker_type)].push_back(std::move(promise));
if (load_installed_sticker_sets_queries_[static_cast<int32>(sticker_type)].size() == 1u) {
if (G()->parameters().use_file_db) {
LOG(INFO) << "Trying to load installed " << (is_masks ? "mask " : "") << "sticker sets from database";
G()->td_db()->get_sqlite_pmc()->get(is_masks ? "sss1" : "sss0", PromiseCreator::lambda([is_masks](string value) {
send_closure(G()->stickers_manager(),
&StickersManager::on_load_installed_sticker_sets_from_database,
is_masks, std::move(value));
}));
LOG(INFO) << "Trying to load installed " << sticker_type << " sticker sets from database";
G()->td_db()->get_sqlite_pmc()->get(
PSTRING() << "sss" << static_cast<int32>(sticker_type), PromiseCreator::lambda([sticker_type](string value) {
send_closure(G()->stickers_manager(), &StickersManager::on_load_installed_sticker_sets_from_database,
sticker_type, std::move(value));
}));
} else {
LOG(INFO) << "Trying to load installed " << (is_masks ? "mask " : "") << "sticker sets from server";
reload_installed_sticker_sets(is_masks, true);
LOG(INFO) << "Trying to load installed " << sticker_type << " sticker sets from server";
reload_installed_sticker_sets(sticker_type, true);
}
}
}
void StickersManager::on_load_installed_sticker_sets_from_database(bool is_masks, string value) {
void StickersManager::on_load_installed_sticker_sets_from_database(StickerType sticker_type, string value) {
if (G()->close_flag()) {
return;
}
if (value.empty()) {
LOG(INFO) << "Installed " << (is_masks ? "mask " : "") << "sticker sets aren't found in database";
reload_installed_sticker_sets(is_masks, true);
LOG(INFO) << "Installed " << sticker_type << " sticker sets aren't found in database";
reload_installed_sticker_sets(sticker_type, true);
return;
}
LOG(INFO) << "Successfully loaded installed " << (is_masks ? "mask " : "") << "sticker set list of size "
<< value.size() << " from database";
LOG(INFO) << "Successfully loaded installed " << sticker_type << " sticker set list of size " << value.size()
<< " from database";
StickerSetListLogEvent log_event;
auto status = log_event_parse(log_event, value);
if (status.is_error()) {
// can't happen unless database is broken
LOG(ERROR) << "Can't load installed sticker set list: " << status << ' ' << format::as_hex_dump<4>(Slice(value));
return reload_installed_sticker_sets(is_masks, true);
return reload_installed_sticker_sets(sticker_type, true);
}
CHECK(!log_event.is_premium_);
@ -4162,56 +4169,59 @@ void StickersManager::on_load_installed_sticker_sets_from_database(bool is_masks
load_sticker_sets_without_stickers(
std::move(sets_to_load),
PromiseCreator::lambda(
[is_masks, sticker_set_ids = std::move(log_event.sticker_set_ids_)](Result<> result) mutable {
if (result.is_ok()) {
send_closure(G()->stickers_manager(), &StickersManager::on_load_installed_sticker_sets_finished, is_masks,
std::move(sticker_set_ids), true);
} else {
send_closure(G()->stickers_manager(), &StickersManager::reload_installed_sticker_sets, is_masks, true);
}
}));
PromiseCreator::lambda([sticker_type,
sticker_set_ids = std::move(log_event.sticker_set_ids_)](Result<Unit> result) mutable {
if (result.is_ok()) {
send_closure(G()->stickers_manager(), &StickersManager::on_load_installed_sticker_sets_finished, sticker_type,
std::move(sticker_set_ids), true);
} else {
send_closure(G()->stickers_manager(), &StickersManager::reload_installed_sticker_sets, sticker_type, true);
}
}));
}
void StickersManager::on_load_installed_sticker_sets_finished(bool is_masks,
void StickersManager::on_load_installed_sticker_sets_finished(StickerType sticker_type,
vector<StickerSetId> &&installed_sticker_set_ids,
bool from_database) {
bool need_reload = false;
vector<StickerSetId> old_installed_sticker_set_ids;
if (!are_installed_sticker_sets_loaded_[is_masks] && !installed_sticker_set_ids_[is_masks].empty()) {
old_installed_sticker_set_ids = std::move(installed_sticker_set_ids_[is_masks]);
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)] &&
!installed_sticker_set_ids_[static_cast<int32>(sticker_type)].empty()) {
old_installed_sticker_set_ids = std::move(installed_sticker_set_ids_[static_cast<int32>(sticker_type)]);
}
installed_sticker_set_ids_[is_masks].clear();
installed_sticker_set_ids_[static_cast<int32>(sticker_type)].clear();
for (auto set_id : installed_sticker_set_ids) {
CHECK(set_id.is_valid());
auto sticker_set = get_sticker_set(set_id);
CHECK(sticker_set != nullptr);
CHECK(sticker_set->is_inited);
CHECK(sticker_set->is_masks == is_masks);
CHECK(sticker_set->sticker_type == sticker_type);
if (sticker_set->is_installed && !sticker_set->is_archived) {
installed_sticker_set_ids_[is_masks].push_back(set_id);
installed_sticker_set_ids_[static_cast<int32>(sticker_type)].push_back(set_id);
} else {
need_reload = true;
}
}
if (need_reload) {
LOG(ERROR) << "Reload installed " << (is_masks ? "mask " : "") << "sticker sets, because only "
<< installed_sticker_set_ids_[is_masks].size() << " of " << installed_sticker_set_ids.size()
<< " are really installed after loading from " << (from_database ? "database" : "server");
reload_installed_sticker_sets(is_masks, true);
LOG(ERROR) << "Reload installed " << sticker_type << " sticker sets, because only "
<< installed_sticker_set_ids_[static_cast<int32>(sticker_type)].size() << " of "
<< installed_sticker_set_ids.size() << " are really installed after loading from "
<< (from_database ? "database" : "server");
reload_installed_sticker_sets(sticker_type, true);
} else if (!old_installed_sticker_set_ids.empty() &&
old_installed_sticker_set_ids != installed_sticker_set_ids_[is_masks]) {
LOG(ERROR) << "Reload installed " << (is_masks ? "mask " : "") << "sticker sets, because they has changed from "
<< old_installed_sticker_set_ids << " to " << installed_sticker_set_ids_[is_masks]
<< " after loading from " << (from_database ? "database" : "server");
reload_installed_sticker_sets(is_masks, true);
old_installed_sticker_set_ids != installed_sticker_set_ids_[static_cast<int32>(sticker_type)]) {
LOG(ERROR) << "Reload installed " << sticker_type << " sticker sets, because they has changed from "
<< old_installed_sticker_set_ids << " to "
<< installed_sticker_set_ids_[static_cast<int32>(sticker_type)] << " after loading from "
<< (from_database ? "database" : "server");
reload_installed_sticker_sets(sticker_type, true);
}
are_installed_sticker_sets_loaded_[is_masks] = true;
need_update_installed_sticker_sets_[is_masks] = true;
are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)] = true;
need_update_installed_sticker_sets_[static_cast<int32>(sticker_type)] = true;
send_update_installed_sticker_sets(from_database);
set_promises(load_installed_sticker_sets_queries_[is_masks]);
set_promises(load_installed_sticker_sets_queries_[static_cast<int32>(sticker_type)]);
}
string StickersManager::get_sticker_set_database_key(StickerSetId set_id) {
@ -4584,13 +4594,11 @@ void StickersManager::on_update_disable_animated_emojis() {
void StickersManager::on_update_sticker_sets() {
// TODO better support
archived_sticker_set_ids_[0].clear();
total_archived_sticker_set_count_[0] = -1;
reload_installed_sticker_sets(false, true);
archived_sticker_set_ids_[1].clear();
total_archived_sticker_set_count_[1] = -1;
reload_installed_sticker_sets(true, true);
for (int32 type = 0; type < MAX_STICKER_TYPE; type++) {
archived_sticker_set_ids_[type].clear();
total_archived_sticker_set_count_[type] = -1;
reload_installed_sticker_sets(static_cast<StickerType>(type), true);
}
}
void StickersManager::try_update_animated_emoji_messages() {
@ -5183,7 +5191,7 @@ void StickersManager::read_featured_sticker_sets(void *td_void) {
td->create_handler<ReadFeaturedStickerSetsQuery>()->send(std::move(sticker_set_ids));
}
std::pair<int32, vector<StickerSetId>> StickersManager::get_archived_sticker_sets(bool is_masks,
std::pair<int32, vector<StickerSetId>> StickersManager::get_archived_sticker_sets(StickerType sticker_type,
StickerSetId offset_sticker_set_id,
int32 limit, bool force,
Promise<Unit> &&promise) {
@ -5192,8 +5200,8 @@ std::pair<int32, vector<StickerSetId>> StickersManager::get_archived_sticker_set
return {};
}
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[is_masks];
int32 total_count = total_archived_sticker_set_count_[is_masks];
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[static_cast<int32>(sticker_type)];
int32 total_count = total_archived_sticker_set_count_[static_cast<int32>(sticker_type)];
if (total_count >= 0) {
auto offset_it = sticker_set_ids.begin();
if (offset_sticker_set_id.is_valid()) {
@ -5222,14 +5230,15 @@ std::pair<int32, vector<StickerSetId>> StickersManager::get_archived_sticker_set
}
}
td_->create_handler<GetArchivedStickerSetsQuery>(std::move(promise))->send(is_masks, offset_sticker_set_id, limit);
td_->create_handler<GetArchivedStickerSetsQuery>(std::move(promise))
->send(sticker_type, offset_sticker_set_id, limit);
return {};
}
void StickersManager::on_get_archived_sticker_sets(
bool is_masks, StickerSetId offset_sticker_set_id,
StickerType sticker_type, StickerSetId offset_sticker_set_id,
vector<tl_object_ptr<telegram_api::StickerSetCovered>> &&sticker_sets, int32 total_count) {
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[is_masks];
vector<StickerSetId> &sticker_set_ids = archived_sticker_set_ids_[static_cast<int32>(sticker_type)];
if (!sticker_set_ids.empty() && sticker_set_ids.back() == StickerSetId()) {
return;
}
@ -5243,7 +5252,7 @@ void StickersManager::on_get_archived_sticker_sets(
sticker_sets.empty() && (!offset_sticker_set_id.is_valid() ||
(!sticker_set_ids.empty() && offset_sticker_set_id == sticker_set_ids.back()));
total_archived_sticker_set_count_[is_masks] = total_count;
total_archived_sticker_set_count_[static_cast<int32>(sticker_type)] = total_count;
for (auto &sticker_set_covered : sticker_sets) {
auto sticker_set_id =
on_get_sticker_set_covered(std::move(sticker_set_covered), false, "on_get_archived_sticker_sets");
@ -5261,7 +5270,7 @@ void StickersManager::on_get_archived_sticker_sets(
if (sticker_set_ids.size() != static_cast<size_t>(total_count)) {
LOG(ERROR) << "Expected total of " << total_count << " archived sticker sets, but " << sticker_set_ids.size()
<< " found";
total_archived_sticker_set_count_[is_masks] = static_cast<int32>(sticker_set_ids.size());
total_archived_sticker_set_count_[static_cast<int32>(sticker_type)] = static_cast<int32>(sticker_set_ids.size());
}
sticker_set_ids.push_back(StickerSetId());
}
@ -5719,12 +5728,13 @@ void StickersManager::on_get_attached_sticker_sets(
// -1 - order can't be applied, because some sticker sets aren't loaded or aren't installed,
// 0 - order wasn't changed, 1 - order was partly replaced by the new order, 2 - order was replaced by the new order
int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vector<StickerSetId> &sticker_set_ids) {
if (!are_installed_sticker_sets_loaded_[is_masks]) {
int StickersManager::apply_installed_sticker_sets_order(StickerType sticker_type,
const vector<StickerSetId> &sticker_set_ids) {
if (!are_installed_sticker_sets_loaded_[static_cast<int32>(sticker_type)]) {
return -1;
}
vector<StickerSetId> &current_sticker_set_ids = installed_sticker_set_ids_[is_masks];
vector<StickerSetId> &current_sticker_set_ids = installed_sticker_set_ids_[static_cast<int32>(sticker_type)];
if (sticker_set_ids == current_sticker_set_ids) {
return 0;
}
@ -5766,31 +5776,34 @@ int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vec
}
current_sticker_set_ids = std::move(new_sticker_set_ids);
need_update_installed_sticker_sets_[is_masks] = true;
need_update_installed_sticker_sets_[static_cast<int32>(sticker_type)] = true;
if (sticker_set_ids != current_sticker_set_ids) {
return 1;
}
return 2;
}
void StickersManager::on_update_sticker_sets_order(bool is_masks, const vector<StickerSetId> &sticker_set_ids) {
int result = apply_installed_sticker_sets_order(is_masks, sticker_set_ids);
void StickersManager::on_update_sticker_sets_order(StickerType sticker_type,
const vector<StickerSetId> &sticker_set_ids) {
int result = apply_installed_sticker_sets_order(sticker_type, sticker_set_ids);
if (result < 0) {
return reload_installed_sticker_sets(is_masks, true);
return reload_installed_sticker_sets(sticker_type, true);
}
if (result > 0) {
send_update_installed_sticker_sets();
}
}
void StickersManager::reorder_installed_sticker_sets(bool is_masks, const vector<StickerSetId> &sticker_set_ids,
void StickersManager::reorder_installed_sticker_sets(StickerType sticker_type,
const vector<StickerSetId> &sticker_set_ids,
Promise<Unit> &&promise) {
auto result = apply_installed_sticker_sets_order(is_masks, sticker_set_ids);
auto result = apply_installed_sticker_sets_order(sticker_type, sticker_set_ids);
if (result < 0) {
return promise.set_error(Status::Error(400, "Wrong sticker set list"));
}
if (result > 0) {
td_->create_handler<ReorderStickerSetsQuery>()->send(is_masks, installed_sticker_set_ids_[is_masks]);
td_->create_handler<ReorderStickerSetsQuery>()->send(sticker_type,
installed_sticker_set_ids_[static_cast<int32>(sticker_type)]);
send_update_installed_sticker_sets();
}
promise.set_value(Unit());
@ -6213,7 +6226,7 @@ void StickersManager::on_new_stickers_uploaded(int64 random_id, Result<Unit> res
auto &promise = pending_new_sticker_set->promise;
TRY_RESULT_PROMISE(promise, input_user, td_->contacts_manager_->get_input_user(pending_new_sticker_set->user_id));
bool is_masks = get_sticker_type(pending_new_sticker_set->stickers[0]->type_) == StickerType::Mask;
StickerType sticker_type = get_sticker_type(pending_new_sticker_set->stickers[0]->type_);
StickerFormat sticker_format = pending_new_sticker_set->sticker_format;
auto sticker_count = pending_new_sticker_set->stickers.size();
@ -6225,7 +6238,7 @@ void StickersManager::on_new_stickers_uploaded(int64 random_id, Result<Unit> res
}
td_->create_handler<CreateNewStickerSetQuery>(std::move(pending_new_sticker_set->promise))
->send(std::move(input_user), pending_new_sticker_set->title, pending_new_sticker_set->short_name, is_masks,
->send(std::move(input_user), pending_new_sticker_set->title, pending_new_sticker_set->short_name, sticker_type,
sticker_format, std::move(input_stickers), pending_new_sticker_set->software);
}
@ -6521,23 +6534,25 @@ vector<StickerSetId> StickersManager::convert_sticker_set_ids(const vector<int64
}
td_api::object_ptr<td_api::updateInstalledStickerSets> StickersManager::get_update_installed_sticker_sets_object(
int is_masks) const {
StickerType sticker_type) const {
return td_api::make_object<td_api::updateInstalledStickerSets>(
is_masks != 0, convert_sticker_set_ids(installed_sticker_set_ids_[is_masks]));
get_sticker_type_object(sticker_type),
convert_sticker_set_ids(installed_sticker_set_ids_[static_cast<int32>(sticker_type)]));
}
void StickersManager::send_update_installed_sticker_sets(bool from_database) {
for (int is_masks = 0; is_masks < 2; is_masks++) {
if (need_update_installed_sticker_sets_[is_masks]) {
need_update_installed_sticker_sets_[is_masks] = false;
if (are_installed_sticker_sets_loaded_[is_masks]) {
installed_sticker_sets_hash_[is_masks] = get_sticker_sets_hash(installed_sticker_set_ids_[is_masks]);
send_closure(G()->td(), &Td::send_update, get_update_installed_sticker_sets_object(is_masks));
for (int32 type = 0; type < MAX_STICKER_TYPE; type++) {
auto sticker_type = static_cast<StickerType>(type);
if (need_update_installed_sticker_sets_[type]) {
need_update_installed_sticker_sets_[type] = false;
if (are_installed_sticker_sets_loaded_[type]) {
installed_sticker_sets_hash_[type] = get_sticker_sets_hash(installed_sticker_set_ids_[type]);
send_closure(G()->td(), &Td::send_update, get_update_installed_sticker_sets_object(sticker_type));
if (G()->parameters().use_file_db && !from_database && !G()->close_flag()) {
LOG(INFO) << "Save installed " << (is_masks ? "mask " : "") << "sticker sets to database";
StickerSetListLogEvent log_event(installed_sticker_set_ids_[is_masks], false);
G()->td_db()->get_sqlite_pmc()->set(is_masks ? "sss1" : "sss0", log_event_store(log_event).as_slice().str(),
LOG(INFO) << "Save installed " << sticker_type << " sticker sets to database";
StickerSetListLogEvent log_event(installed_sticker_set_ids_[type], false);
G()->td_db()->get_sqlite_pmc()->set(PSTRING() << "sss" << type, log_event_store(log_event).as_slice().str(),
Auto());
}
}
@ -7845,9 +7860,9 @@ void StickersManager::get_current_state(vector<td_api::object_ptr<td_api::Update
if (!reactions_.reactions_.empty()) {
updates.push_back(get_update_reactions_object());
}
for (int is_masks = 0; is_masks < 2; is_masks++) {
if (are_installed_sticker_sets_loaded_[is_masks]) {
updates.push_back(get_update_installed_sticker_sets_object(is_masks));
for (int32 type = 0; type < MAX_STICKER_TYPE; type++) {
if (are_installed_sticker_sets_loaded_[type]) {
updates.push_back(get_update_installed_sticker_sets_object(static_cast<StickerType>(type)));
}
}
if (are_featured_sticker_sets_loaded_) {

56
td/telegram/StickersManager.h
View File

@ -121,7 +121,7 @@ class StickersManager final : public Actor {
vector<FileId> search_stickers(string emoji, int32 limit, Promise<Unit> &&promise);
vector<StickerSetId> get_installed_sticker_sets(bool is_masks, Promise<Unit> &&promise);
vector<StickerSetId> get_installed_sticker_sets(StickerType sticker_type, Promise<Unit> &&promise);
static bool has_webp_thumbnail(const vector<tl_object_ptr<telegram_api::PhotoSize>> &thumbnails);
@ -133,8 +133,8 @@ class StickersManager final : public Actor {
StickerSetId search_sticker_set(const string &short_name_to_search, Promise<Unit> &&promise);
std::pair<int32, vector<StickerSetId>> search_installed_sticker_sets(bool is_masks, const string &query, int32 limit,
Promise<Unit> &&promise);
std::pair<int32, vector<StickerSetId>> search_installed_sticker_sets(StickerType sticker_type, const string &query,
int32 limit, Promise<Unit> &&promise);
vector<StickerSetId> search_sticker_sets(const string &query, Promise<Unit> &&promise);
@ -148,9 +148,10 @@ class StickersManager final : public Actor {
void on_get_available_reactions(tl_object_ptr<telegram_api::messages_AvailableReactions> &&available_reactions_ptr);
void on_get_installed_sticker_sets(bool is_masks, tl_object_ptr<telegram_api::messages_AllStickers> &&stickers_ptr);
void on_get_installed_sticker_sets(StickerType sticker_type,
tl_object_ptr<telegram_api::messages_AllStickers> &&stickers_ptr);
void on_get_installed_sticker_sets_failed(bool is_masks, Status error);
void on_get_installed_sticker_sets_failed(StickerType sticker_type, Status error);
StickerSetId on_get_messages_sticker_set(StickerSetId sticker_set_id,
tl_object_ptr<telegram_api::messages_StickerSet> &&set_ptr, bool is_changed,
@ -184,12 +185,13 @@ class StickersManager final : public Actor {
void on_update_sticker_sets();
void on_update_sticker_sets_order(bool is_masks, const vector<StickerSetId> &sticker_set_ids);
void on_update_sticker_sets_order(StickerType sticker_type, const vector<StickerSetId> &sticker_set_ids);
std::pair<int32, vector<StickerSetId>> get_archived_sticker_sets(bool is_masks, StickerSetId offset_sticker_set_id,
int32 limit, bool force, Promise<Unit> &&promise);
std::pair<int32, vector<StickerSetId>> get_archived_sticker_sets(StickerType sticker_type,
StickerSetId offset_sticker_set_id, int32 limit,
bool force, Promise<Unit> &&promise);
void on_get_archived_sticker_sets(bool is_masks, StickerSetId offset_sticker_set_id,
void on_get_archived_sticker_sets(StickerType sticker_type, StickerSetId offset_sticker_set_id,
vector<tl_object_ptr<telegram_api::StickerSetCovered>> &&sticker_sets,
int32 total_count);
@ -206,7 +208,7 @@ class StickersManager final : public Actor {
void on_get_attached_sticker_sets(FileId file_id,
vector<tl_object_ptr<telegram_api::StickerSetCovered>> &&sticker_sets);
void reorder_installed_sticker_sets(bool is_masks, const vector<StickerSetId> &sticker_set_ids,
void reorder_installed_sticker_sets(StickerType sticker_type, const vector<StickerSetId> &sticker_set_ids,
Promise<Unit> &&promise);
FileId upload_sticker_file(UserId user_id, tl_object_ptr<td_api::inputSticker> &&sticker, Promise<Unit> &&promise);
@ -295,7 +297,7 @@ class StickersManager final : public Actor {
void reload_sticker_set(StickerSetId sticker_set_id, int64 access_hash, Promise<Unit> &&promise);
void reload_installed_sticker_sets(bool is_masks, bool force);
void reload_installed_sticker_sets(StickerType sticker_type, bool force);
void reload_featured_sticker_sets(bool force);
@ -381,6 +383,7 @@ class StickersManager final : public Actor {
string title;
string short_name;
StickerFormat sticker_format = StickerFormat::Unknown;
StickerType sticker_type = StickerType::Regular;
int32 sticker_count = 0;
int32 hash = 0;
int32 expires_at = 0;
@ -395,7 +398,6 @@ class StickersManager final : public Actor {
bool is_installed = false;
bool is_archived = false;
bool is_official = false;
bool is_masks = false;
bool is_viewed = true;
bool is_thumbnail_reloaded = false;
bool are_legacy_sticker_thumbnails_reloaded = false;
@ -533,7 +535,7 @@ class StickersManager final : public Actor {
void on_resolve_sticker_set_short_name(FileId sticker_file_id, const string &short_name);
int apply_installed_sticker_sets_order(bool is_masks, const vector<StickerSetId> &sticker_set_ids);
int apply_installed_sticker_sets_order(StickerType sticker_type, const vector<StickerSetId> &sticker_set_ids);
void on_update_sticker_set(StickerSet *sticker_set, bool is_installed, bool is_archived, bool is_changed,
bool from_database = false);
@ -568,7 +570,7 @@ class StickersManager final : public Actor {
int64 get_recent_stickers_hash(const vector<FileId> &sticker_ids) const;
void load_installed_sticker_sets(bool is_masks, Promise<Unit> &&promise);
void load_installed_sticker_sets(StickerType sticker_type, Promise<Unit> &&promise);
void load_featured_sticker_sets(Promise<Unit> &&promise);
@ -576,9 +578,10 @@ class StickersManager final : public Actor {
void load_recent_stickers(bool is_attached, Promise<Unit> &&promise);
void on_load_installed_sticker_sets_from_database(bool is_masks, string value);
void on_load_installed_sticker_sets_from_database(StickerType sticker_type, string value);
void on_load_installed_sticker_sets_finished(bool is_masks, vector<StickerSetId> &&installed_sticker_set_ids,
void on_load_installed_sticker_sets_finished(StickerType sticker_type,
vector<StickerSetId> &&installed_sticker_set_ids,
bool from_database = false);
void on_load_featured_sticker_sets_from_database(string value);
@ -595,7 +598,8 @@ class StickersManager final : public Actor {
void on_load_recent_stickers_finished(bool is_attached, vector<FileId> &&recent_sticker_ids,
bool from_database = false);
td_api::object_ptr<td_api::updateInstalledStickerSets> get_update_installed_sticker_sets_object(int is_masks) const;
td_api::object_ptr<td_api::updateInstalledStickerSets> get_update_installed_sticker_sets_object(
StickerType sticker_type) const;
void send_update_installed_sticker_sets(bool from_database = false);
@ -788,28 +792,28 @@ class StickersManager final : public Actor {
FlatHashMap<StickerSetId, unique_ptr<StickerSet>, StickerSetIdHash> sticker_sets_; // id -> StickerSet
FlatHashMap<string, StickerSetId> short_name_to_sticker_set_id_;
vector<StickerSetId> installed_sticker_set_ids_[2];
vector<StickerSetId> installed_sticker_set_ids_[MAX_STICKER_TYPE];
vector<StickerSetId> featured_sticker_set_ids_;
vector<StickerSetId> old_featured_sticker_set_ids_;
vector<FileId> recent_sticker_ids_[2];
vector<FileId> favorite_sticker_ids_;
double next_installed_sticker_sets_load_time_[2] = {0, 0};
double next_installed_sticker_sets_load_time_[MAX_STICKER_TYPE] = {0, 0};
double next_featured_sticker_sets_load_time_ = 0;
double next_recent_stickers_load_time_[2] = {0, 0};
double next_favorite_stickers_load_time_ = 0;
int64 installed_sticker_sets_hash_[2] = {0, 0};
int64 installed_sticker_sets_hash_[MAX_STICKER_TYPE] = {0, 0};
int64 featured_sticker_sets_hash_ = 0;
int64 recent_stickers_hash_[2] = {0, 0};
int32 old_featured_sticker_set_count_ = -1;
uint32 old_featured_sticker_set_generation_ = 1;
bool need_update_installed_sticker_sets_[2] = {false, false};
bool need_update_installed_sticker_sets_[MAX_STICKER_TYPE] = {false, false};
bool need_update_featured_sticker_sets_ = false;
bool are_installed_sticker_sets_loaded_[2] = {false, false};
bool are_installed_sticker_sets_loaded_[MAX_STICKER_TYPE] = {false, false};
bool are_featured_sticker_sets_loaded_ = false;
bool are_recent_stickers_loaded_[2] = {false, false};
bool are_favorite_stickers_loaded_ = false;
@ -817,7 +821,7 @@ class StickersManager final : public Actor {
bool are_featured_sticker_sets_premium_ = false;
bool are_old_featured_sticker_sets_invalidated_ = false;
vector<Promise<Unit>> load_installed_sticker_sets_queries_[2];
vector<Promise<Unit>> load_installed_sticker_sets_queries_[MAX_STICKER_TYPE];
vector<Promise<Unit>> load_featured_sticker_sets_queries_;
vector<Promise<Unit>> load_old_featured_sticker_sets_queries_;
vector<Promise<Unit>> load_recent_stickers_queries_[2];
@ -832,12 +836,12 @@ class StickersManager final : public Actor {
FileSourceId app_config_file_source_id_;
vector<StickerSetId> archived_sticker_set_ids_[2];
int32 total_archived_sticker_set_count_[2] = {-1, -1};
vector<StickerSetId> archived_sticker_set_ids_[MAX_STICKER_TYPE];
int32 total_archived_sticker_set_count_[MAX_STICKER_TYPE] = {-1, -1};
FlatHashMap<FileId, vector<StickerSetId>, FileIdHash> attached_sticker_sets_;
Hints installed_sticker_sets_hints_[2]; // search installed sticker sets by their title and name
Hints installed_sticker_sets_hints_[MAX_STICKER_TYPE]; // search installed sticker sets by their title and name
struct FoundStickers {
vector<FileId> sticker_ids_;

15
td/telegram/StickersManager.hpp
View File

@ -168,6 +168,7 @@ void StickersManager::store_sticker_set(const StickerSet *sticker_set, bool with
bool has_minithumbnail = !sticker_set->minithumbnail.empty();
bool is_tgs = sticker_set->sticker_format == StickerFormat::Tgs;
bool is_webm = sticker_set->sticker_format == StickerFormat::Webm;
bool is_masks = sticker_set->sticker_type == StickerType::Mask;
BEGIN_STORE_FLAGS();
STORE_FLAG(sticker_set->is_inited);
STORE_FLAG(was_loaded);
@ -175,7 +176,7 @@ void StickersManager::store_sticker_set(const StickerSet *sticker_set, bool with
STORE_FLAG(sticker_set->is_installed);
STORE_FLAG(sticker_set->is_archived);
STORE_FLAG(sticker_set->is_official);
STORE_FLAG(sticker_set->is_masks);
STORE_FLAG(is_masks);
STORE_FLAG(sticker_set->is_viewed);
STORE_FLAG(has_expires_at);
STORE_FLAG(has_thumbnail);
@ -269,6 +270,10 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser
} else {
sticker_format = StickerFormat::Webp;
}
StickerType sticker_type = StickerType::Regular;
if (is_masks) {
sticker_type = StickerType::Regular;
}
if (sticker_set->is_inited) {
string title;
@ -301,7 +306,7 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser
sticker_set->hash = hash;
sticker_set->expires_at = expires_at;
sticker_set->is_official = is_official;
sticker_set->is_masks = is_masks;
sticker_set->sticker_type = sticker_type;
sticker_set->sticker_format = sticker_format;
auto cleaned_username = clean_username(sticker_set->short_name);
@ -324,9 +329,9 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser
LOG(ERROR) << "Sticker format of " << sticker_set->id << " has changed from \"" << sticker_format << "\" to \""
<< sticker_set->sticker_format << "\"";
}
if (sticker_set->is_masks != is_masks) {
LOG(ERROR) << "Is masks of " << sticker_set->id << " has changed from \"" << is_masks << "\" to \""
<< sticker_set->is_masks << "\"";
if (sticker_set->sticker_type != sticker_type) {
LOG(ERROR) << "Type of " << sticker_set->id << " has changed from \"" << sticker_type << "\" to \""
<< sticker_set->sticker_type << "\"";
}
}

41
td/telegram/Td.cpp
View File

@ -108,6 +108,7 @@
#include "td/telegram/StateManager.h"
#include "td/telegram/StickerSetId.h"
#include "td/telegram/StickersManager.h"
#include "td/telegram/StickerType.h"
#include "td/telegram/StorageManager.h"
#include "td/telegram/SuggestedAction.h"
#include "td/telegram/td_api.hpp"
@ -2023,12 +2024,12 @@ class SearchStickersRequest final : public RequestActor<> {
};
class GetInstalledStickerSetsRequest final : public RequestActor<> {
bool is_masks_;
StickerType sticker_type_;
vector<StickerSetId> sticker_set_ids_;
void do_run(Promise<Unit> &&promise) final {
sticker_set_ids_ = td_->stickers_manager_->get_installed_sticker_sets(is_masks_, std::move(promise));
sticker_set_ids_ = td_->stickers_manager_->get_installed_sticker_sets(sticker_type_, std::move(promise));
}
void do_send_result() final {
@ -2036,13 +2037,13 @@ class GetInstalledStickerSetsRequest final : public RequestActor<> {
}
public:
GetInstalledStickerSetsRequest(ActorShared<Td> td, uint64 request_id, bool is_masks)
: RequestActor(std::move(td), request_id), is_masks_(is_masks) {
GetInstalledStickerSetsRequest(ActorShared<Td> td, uint64 request_id, StickerType sticker_type)
: RequestActor(std::move(td), request_id), sticker_type_(sticker_type) {
}
};
class GetArchivedStickerSetsRequest final : public RequestActor<> {
bool is_masks_;
StickerType sticker_type_;
StickerSetId offset_sticker_set_id_;
int32 limit_;
@ -2051,7 +2052,7 @@ class GetArchivedStickerSetsRequest final : public RequestActor<> {
void do_run(Promise<Unit> &&promise) final {
std::tie(total_count_, sticker_set_ids_) = td_->stickers_manager_->get_archived_sticker_sets(
is_masks_, offset_sticker_set_id_, limit_, get_tries() < 2, std::move(promise));
sticker_type_, offset_sticker_set_id_, limit_, get_tries() < 2, std::move(promise));
}
void do_send_result() final {
@ -2059,10 +2060,10 @@ class GetArchivedStickerSetsRequest final : public RequestActor<> {
}
public:
GetArchivedStickerSetsRequest(ActorShared<Td> td, uint64 request_id, bool is_masks, int64 offset_sticker_set_id,
int32 limit)
GetArchivedStickerSetsRequest(ActorShared<Td> td, uint64 request_id, StickerType sticker_type,
int64 offset_sticker_set_id, int32 limit)
: RequestActor(std::move(td), request_id)
, is_masks_(is_masks)
, sticker_type_(sticker_type)
, offset_sticker_set_id_(offset_sticker_set_id)
, limit_(limit) {
}
@ -2148,7 +2149,7 @@ class SearchStickerSetRequest final : public RequestActor<> {
};
class SearchInstalledStickerSetsRequest final : public RequestActor<> {
bool is_masks_;
StickerType sticker_type_;
string query_;
int32 limit_;
@ -2156,7 +2157,7 @@ class SearchInstalledStickerSetsRequest final : public RequestActor<> {
void do_run(Promise<Unit> &&promise) final {
sticker_set_ids_ =
td_->stickers_manager_->search_installed_sticker_sets(is_masks_, query_, limit_, std::move(promise));
td_->stickers_manager_->search_installed_sticker_sets(sticker_type_, query_, limit_, std::move(promise));
}
void do_send_result() final {
@ -2164,8 +2165,9 @@ class SearchInstalledStickerSetsRequest final : public RequestActor<> {
}
public:
SearchInstalledStickerSetsRequest(ActorShared<Td> td, uint64 request_id, bool is_masks, string &&query, int32 limit)
: RequestActor(std::move(td), request_id), is_masks_(is_masks), query_(std::move(query)), limit_(limit) {
SearchInstalledStickerSetsRequest(ActorShared<Td> td, uint64 request_id, StickerType sticker_type, string &&query,
int32 limit)
: RequestActor(std::move(td), request_id), sticker_type_(sticker_type), query_(std::move(query)), limit_(limit) {
}
};
@ -6989,12 +6991,13 @@ void Td::on_request(uint64 id, td_api::searchStickers &request) {
void Td::on_request(uint64 id, const td_api::getInstalledStickerSets &request) {
CHECK_IS_USER();
CREATE_REQUEST(GetInstalledStickerSetsRequest, request.is_masks_);
CREATE_REQUEST(GetInstalledStickerSetsRequest, get_sticker_type(request.sticker_type_));
}
void Td::on_request(uint64 id, const td_api::getArchivedStickerSets &request) {
CHECK_IS_USER();
CREATE_REQUEST(GetArchivedStickerSetsRequest, request.is_masks_, request.offset_sticker_set_id_, request.limit_);
CREATE_REQUEST(GetArchivedStickerSetsRequest, get_sticker_type(request.sticker_type_), request.offset_sticker_set_id_,
request.limit_);
}
void Td::on_request(uint64 id, const td_api::getTrendingStickerSets &request) {
@ -7018,7 +7021,8 @@ void Td::on_request(uint64 id, td_api::searchStickerSet &request) {
void Td::on_request(uint64 id, td_api::searchInstalledStickerSets &request) {
CLEAN_INPUT_STRING(request.query_);
CREATE_REQUEST(SearchInstalledStickerSetsRequest, request.is_masks_, std::move(request.query_), request.limit_);
CREATE_REQUEST(SearchInstalledStickerSetsRequest, get_sticker_type(request.sticker_type_), std::move(request.query_),
request.limit_);
}
void Td::on_request(uint64 id, td_api::searchStickerSets &request) {
@ -7040,8 +7044,9 @@ void Td::on_request(uint64 id, const td_api::viewTrendingStickerSets &request) {
void Td::on_request(uint64 id, td_api::reorderInstalledStickerSets &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
stickers_manager_->reorder_installed_sticker_sets(
request.is_masks_, StickersManager::convert_sticker_set_ids(request.sticker_set_ids_), std::move(promise));
stickers_manager_->reorder_installed_sticker_sets(get_sticker_type(request.sticker_type_),
StickersManager::convert_sticker_set_ids(request.sticker_set_ids_),
std::move(promise));
}
void Td::on_request(uint64 id, td_api::uploadStickerFile &request) {

10
td/telegram/UpdatesManager.cpp
View File

@ -1674,8 +1674,8 @@ void UpdatesManager::try_reload_data() {
td_->notification_settings_manager_->send_get_scope_notification_settings_query(NotificationSettingsScope::Channel,
Auto());
td_->stickers_manager_->reload_reactions();
td_->stickers_manager_->get_installed_sticker_sets(false, Auto());
td_->stickers_manager_->get_installed_sticker_sets(true, Auto());
td_->stickers_manager_->get_installed_sticker_sets(StickerType::Regular, Auto());
td_->stickers_manager_->get_installed_sticker_sets(StickerType::Mask, Auto());
td_->stickers_manager_->get_featured_sticker_sets(0, 1000, Auto());
td_->stickers_manager_->get_recent_stickers(false, Auto());
td_->stickers_manager_->get_recent_stickers(true, Auto());
@ -3314,7 +3314,11 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateStickerSets> up
}
void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateStickerSetsOrder> update, Promise<Unit> &&promise) {
td_->stickers_manager_->on_update_sticker_sets_order(update->masks_,
StickerType sticker_type = StickerType::Regular;
if (update->masks_) {
sticker_type = StickerType::Mask;
}
td_->stickers_manager_->on_update_sticker_sets_order(sticker_type,
StickersManager::convert_sticker_set_ids(update->order_));
promise.set_value(Unit());
}

23
td/telegram/cli.cpp
View File

@ -2619,15 +2619,14 @@ class CliClient final : public Actor {
int64 sticker_set_id;
get_args(args, sticker_set_id);
send_request(td_api::make_object<td_api::getStickerSet>(sticker_set_id));
} else if (op == "giss") {
send_request(td_api::make_object<td_api::getInstalledStickerSets>(as_bool(args)));
} else if (op == "gass") {
bool is_masks;
} else if (op == "giss" || op == "gissm") {
send_request(td_api::make_object<td_api::getInstalledStickerSets>(as_sticker_type(args)));
} else if (op == "gass" || op == "gassm") {
int64 offset_sticker_set_id;
string limit;
get_args(args, is_masks, offset_sticker_set_id, limit);
send_request(
td_api::make_object<td_api::getArchivedStickerSets>(is_masks, offset_sticker_set_id, as_limit(limit)));
get_args(args, offset_sticker_set_id, limit);
send_request(td_api::make_object<td_api::getArchivedStickerSets>(as_sticker_type(op), offset_sticker_set_id,
as_limit(limit)));
} else if (op == "gtss") {
int32 offset;
string limit;
@ -2740,7 +2739,7 @@ class CliClient final : public Actor {
} else if (op == "sss") {
send_request(td_api::make_object<td_api::searchStickerSet>(args));
} else if (op == "siss") {
send_request(td_api::make_object<td_api::searchInstalledStickerSets>(false, args, 2));
send_request(td_api::make_object<td_api::searchInstalledStickerSets>(nullptr, args, 2));
} else if (op == "ssss") {
send_request(td_api::make_object<td_api::searchStickerSets>(args));
} else if (op == "css") {
@ -2751,11 +2750,11 @@ class CliClient final : public Actor {
send_request(td_api::make_object<td_api::changeStickerSet>(set_id, is_installed, is_archived));
} else if (op == "vtss") {
send_request(td_api::make_object<td_api::viewTrendingStickerSets>(to_integers<int64>(args)));
} else if (op == "riss") {
bool is_masks;
} else if (op == "riss" || op == "rissm") {
string new_order;
get_args(args, is_masks, new_order);
send_request(td_api::make_object<td_api::reorderInstalledStickerSets>(is_masks, to_integers<int64>(new_order)));
get_args(args, new_order);
send_request(
td_api::make_object<td_api::reorderInstalledStickerSets>(as_sticker_type(op), to_integers<int64>(new_order)));
} else if (op == "grs") {
send_request(td_api::make_object<td_api::getRecentStickers>(as_bool(args)));
} else if (op == "ars") {