187 lines
7.2 KiB
C++
187 lines
7.2 KiB
C++
//
|
|
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
#include "td/telegram/StickerPhotoSize.h"
|
|
|
|
#include "td/telegram/StickersManager.h"
|
|
#include "td/telegram/Td.h"
|
|
|
|
#include "td/utils/logging.h"
|
|
|
|
namespace td {
|
|
|
|
Result<unique_ptr<StickerPhotoSize>> StickerPhotoSize::get_sticker_photo_size(
|
|
Td *td, const td_api::object_ptr<td_api::chatPhotoSticker> &sticker) {
|
|
if (sticker == nullptr) {
|
|
return Status::Error(400, "Sticker must not be null");
|
|
}
|
|
if (sticker->type_ == nullptr) {
|
|
return Status::Error(400, "Type must be non-null");
|
|
}
|
|
if (sticker->background_fill_ == nullptr) {
|
|
return Status::Error(400, "Background must be non-null");
|
|
}
|
|
auto result = make_unique<StickerPhotoSize>();
|
|
switch (sticker->type_->get_id()) {
|
|
case td_api::chatPhotoStickerTypeRegularOrMask::ID: {
|
|
auto type = static_cast<const td_api::chatPhotoStickerTypeRegularOrMask *>(sticker->type_.get());
|
|
result->type_ = Type::Sticker;
|
|
result->sticker_set_id_ = StickerSetId(type->sticker_set_id_);
|
|
result->sticker_id_ = type->sticker_id_;
|
|
if (!td->stickers_manager_->have_sticker(result->sticker_set_id_, result->sticker_id_)) {
|
|
return Status::Error(400, "Sticker not found");
|
|
}
|
|
break;
|
|
}
|
|
case td_api::chatPhotoStickerTypeCustomEmoji::ID: {
|
|
auto type = static_cast<const td_api::chatPhotoStickerTypeCustomEmoji *>(sticker->type_.get());
|
|
result->type_ = Type::CustomEmoji;
|
|
result->custom_emoji_id_ = CustomEmojiId(type->custom_emoji_id_);
|
|
if (!td->stickers_manager_->have_custom_emoji(result->custom_emoji_id_)) {
|
|
return Status::Error(400, "Custom emoji not found");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
auto fill = sticker->background_fill_.get();
|
|
switch (fill->get_id()) {
|
|
case td_api::backgroundFillSolid::ID: {
|
|
auto solid = static_cast<const td_api::backgroundFillSolid *>(fill);
|
|
result->background_colors_.push_back(solid->color_);
|
|
break;
|
|
}
|
|
case td_api::backgroundFillGradient::ID: {
|
|
auto gradient = static_cast<const td_api::backgroundFillGradient *>(fill);
|
|
result->background_colors_.push_back(gradient->top_color_);
|
|
result->background_colors_.push_back(gradient->bottom_color_);
|
|
break;
|
|
}
|
|
case td_api::backgroundFillFreeformGradient::ID: {
|
|
auto freeform = static_cast<const td_api::backgroundFillFreeformGradient *>(fill);
|
|
if (freeform->colors_.size() != 3 && freeform->colors_.size() != 4) {
|
|
return Status::Error(400, "Invalid number of colors specified");
|
|
}
|
|
result->background_colors_ = freeform->colors_;
|
|
break;
|
|
}
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
for (auto &color : result->background_colors_) {
|
|
color &= 0xFFFFFF;
|
|
}
|
|
return std::move(result);
|
|
}
|
|
|
|
telegram_api::object_ptr<telegram_api::VideoSize> StickerPhotoSize::get_input_video_size_object(Td *td) const {
|
|
switch (type_) {
|
|
case Type::Sticker:
|
|
return telegram_api::make_object<telegram_api::videoSizeStickerMarkup>(
|
|
td->stickers_manager_->get_input_sticker_set(sticker_set_id_), sticker_id_,
|
|
vector<int32>(background_colors_));
|
|
case Type::CustomEmoji:
|
|
return telegram_api::make_object<telegram_api::videoSizeEmojiMarkup>(custom_emoji_id_.get(),
|
|
vector<int32>(background_colors_));
|
|
default:
|
|
UNREACHABLE();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
unique_ptr<StickerPhotoSize> StickerPhotoSize::get_sticker_photo_size(
|
|
Td *td, telegram_api::object_ptr<telegram_api::VideoSize> &&size_ptr) {
|
|
CHECK(size_ptr != nullptr);
|
|
auto result = make_unique<StickerPhotoSize>();
|
|
bool is_valid = false;
|
|
switch (size_ptr->get_id()) {
|
|
case telegram_api::videoSizeEmojiMarkup::ID: {
|
|
auto size = move_tl_object_as<telegram_api::videoSizeEmojiMarkup>(size_ptr);
|
|
result->type_ = Type::CustomEmoji;
|
|
result->custom_emoji_id_ = CustomEmojiId(size->emoji_id_);
|
|
result->background_colors_ = std::move(size->background_colors_);
|
|
is_valid = result->custom_emoji_id_.is_valid();
|
|
break;
|
|
}
|
|
case telegram_api::videoSizeStickerMarkup::ID: {
|
|
auto size = move_tl_object_as<telegram_api::videoSizeStickerMarkup>(size_ptr);
|
|
result->type_ = Type::Sticker;
|
|
result->sticker_set_id_ = td->stickers_manager_->add_sticker_set(std::move(size->stickerset_));
|
|
result->sticker_id_ = size->sticker_id_;
|
|
result->background_colors_ = std::move(size->background_colors_);
|
|
is_valid = result->sticker_set_id_.is_valid() && result->sticker_id_ != 0;
|
|
break;
|
|
}
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
if (!is_valid || result->background_colors_.empty() || result->background_colors_.size() > 4) {
|
|
LOG(ERROR) << "Receive invalid " << *result;
|
|
return {};
|
|
}
|
|
for (auto &color : result->background_colors_) {
|
|
color &= 0xFFFFFF;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
td_api::object_ptr<td_api::chatPhotoSticker> StickerPhotoSize::get_chat_photo_sticker_object() const {
|
|
td_api::object_ptr<td_api::ChatPhotoStickerType> sticker_type;
|
|
switch (type_) {
|
|
case Type::Sticker:
|
|
sticker_type = td_api::make_object<td_api::chatPhotoStickerTypeRegularOrMask>(sticker_set_id_.get(), sticker_id_);
|
|
break;
|
|
case Type::CustomEmoji:
|
|
sticker_type = td_api::make_object<td_api::chatPhotoStickerTypeCustomEmoji>(custom_emoji_id_.get());
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
return nullptr;
|
|
}
|
|
CHECK(sticker_type != nullptr);
|
|
|
|
auto background_fill = [&](vector<int32> colors) -> td_api::object_ptr<td_api::BackgroundFill> {
|
|
switch (colors.size()) {
|
|
case 1:
|
|
return td_api::make_object<td_api::backgroundFillSolid>(colors[0]);
|
|
case 2:
|
|
return td_api::make_object<td_api::backgroundFillGradient>(colors[0], colors[1], 0);
|
|
case 3:
|
|
case 4:
|
|
return td_api::make_object<td_api::backgroundFillFreeformGradient>(std::move(colors));
|
|
default:
|
|
UNREACHABLE();
|
|
return nullptr;
|
|
}
|
|
}(background_colors_);
|
|
|
|
return td_api::make_object<td_api::chatPhotoSticker>(std::move(sticker_type), std::move(background_fill));
|
|
}
|
|
|
|
bool operator==(const StickerPhotoSize &lhs, const StickerPhotoSize &rhs) {
|
|
return lhs.type_ == rhs.type_ && lhs.sticker_set_id_ == rhs.sticker_set_id_ && lhs.sticker_id_ == rhs.sticker_id_ &&
|
|
lhs.custom_emoji_id_ == rhs.custom_emoji_id_ && lhs.background_colors_ == rhs.background_colors_;
|
|
}
|
|
|
|
bool operator!=(const StickerPhotoSize &lhs, const StickerPhotoSize &rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const StickerPhotoSize &sticker_photo_size) {
|
|
switch (sticker_photo_size.type_) {
|
|
case StickerPhotoSize::Type::Sticker:
|
|
return string_builder << sticker_photo_size.sticker_id_ << " from " << sticker_photo_size.sticker_set_id_
|
|
<< " on " << sticker_photo_size.background_colors_;
|
|
case StickerPhotoSize::Type::CustomEmoji:
|
|
return string_builder << sticker_photo_size.custom_emoji_id_ << " on " << sticker_photo_size.background_colors_;
|
|
default:
|
|
UNREACHABLE();
|
|
return string_builder;
|
|
}
|
|
}
|
|
|
|
} // namespace td
|