tdesktop/Telegram/SourceFiles/chat_helpers/stickers_emoji_pack.cpp

445 lines
12 KiB
C++
Raw Normal View History

2019-08-01 14:13:02 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "chat_helpers/stickers_emoji_pack.h"
#include "chat_helpers/stickers_emoji_image_loader.h"
2019-08-01 14:13:02 +00:00
#include "history/history_item.h"
2019-08-07 14:22:51 +00:00
#include "lottie/lottie_common.h"
2019-08-01 14:13:02 +00:00
#include "ui/emoji_config.h"
2019-08-02 18:19:14 +00:00
#include "ui/text/text_isolated_emoji.h"
2020-05-29 15:10:25 +00:00
#include "ui/image/image.h"
2019-08-01 14:13:02 +00:00
#include "main/main_session.h"
2019-08-02 18:19:14 +00:00
#include "data/data_file_origin.h"
2019-08-01 14:13:02 +00:00
#include "data/data_session.h"
#include "data/data_document.h"
#include "core/core_settings.h"
#include "core/application.h"
2019-09-26 10:55:35 +00:00
#include "base/call_delayed.h"
#include "chat_helpers/stickers_lottie.h"
#include "history/view/media/history_view_sticker.h"
#include "lottie/lottie_single_player.h"
2019-08-01 14:13:02 +00:00
#include "apiwrap.h"
2020-10-10 09:15:37 +00:00
#include "styles/style_chat.h"
2019-08-01 14:13:02 +00:00
2019-09-04 07:19:15 +00:00
#include <QtCore/QBuffer>
2019-08-01 14:13:02 +00:00
namespace Stickers {
namespace {
2019-09-11 10:49:27 +00:00
constexpr auto kRefreshTimeout = 7200 * crl::time(1000);
constexpr auto kEmojiCachesCount = 4;
constexpr auto kPremiumCachesCount = 8;
2019-08-02 18:19:14 +00:00
2021-09-14 16:55:35 +00:00
[[nodiscard]] std::optional<int> IndexFromEmoticon(const QString &emoticon) {
if (emoticon.size() < 2) {
return std::nullopt;
2021-09-14 16:55:35 +00:00
}
const auto first = emoticon[0].unicode();
return (first >= '1' && first <= '9')
? std::make_optional(first - '1')
2021-09-14 16:55:35 +00:00
: (first == 55357 && emoticon[1].unicode() == 56607)
? std::make_optional(9)
: std::nullopt;
2021-09-14 16:55:35 +00:00
}
2019-08-05 11:44:40 +00:00
[[nodiscard]] QSize SingleSize() {
2019-08-02 18:19:14 +00:00
const auto single = st::largeEmojiSize;
const auto outline = st::largeEmojiOutline;
return QSize(
2019-08-05 11:44:40 +00:00
2 * outline + single,
2019-08-02 18:19:14 +00:00
2 * outline + single
) * cIntRetinaFactor();
}
2019-08-07 14:22:51 +00:00
[[nodiscard]] const Lottie::ColorReplacements *ColorReplacements(int index) {
Expects(index >= 1 && index <= 5);
static const auto color1 = Lottie::ColorReplacements{
.modifier = Lottie::SkinModifier::Color1,
.tag = 1,
2019-08-07 14:22:51 +00:00
};
static const auto color2 = Lottie::ColorReplacements{
.modifier = Lottie::SkinModifier::Color2,
.tag = 2,
2019-08-07 14:22:51 +00:00
};
static const auto color3 = Lottie::ColorReplacements{
.modifier = Lottie::SkinModifier::Color3,
.tag = 3,
2019-08-07 14:22:51 +00:00
};
static const auto color4 = Lottie::ColorReplacements{
.modifier = Lottie::SkinModifier::Color4,
.tag = 4,
2019-08-07 14:22:51 +00:00
};
static const auto color5 = Lottie::ColorReplacements{
.modifier = Lottie::SkinModifier::Color5,
.tag = 5,
2019-08-07 14:22:51 +00:00
};
static const auto list = std::array{
&color1,
&color2,
&color3,
&color4,
&color5,
};
return list[index - 1];
}
2019-08-01 14:13:02 +00:00
} // namespace
2020-05-29 14:29:21 +00:00
QSize LargeEmojiImage::Size() {
return SingleSize();
2020-05-29 14:29:21 +00:00
}
2019-08-02 18:19:14 +00:00
EmojiPack::EmojiPack(not_null<Main::Session*> session)
: _session(session) {
2019-08-01 14:13:02 +00:00
refresh();
2019-08-01 21:14:19 +00:00
session->data().itemRemoved(
) | rpl::filter([](not_null<const HistoryItem*> item) {
2019-08-02 18:19:14 +00:00
return item->isIsolatedEmoji();
2019-08-01 21:14:19 +00:00
}) | rpl::start_with_next([=](not_null<const HistoryItem*> item) {
remove(item);
}, _lifetime);
2019-08-02 10:52:35 +00:00
Core::App().settings().largeEmojiChanges(
2019-08-05 14:08:20 +00:00
) | rpl::start_with_next([=](bool large) {
2019-08-02 18:19:14 +00:00
refreshAll();
}, _lifetime);
Ui::Emoji::Updated(
) | rpl::start_with_next([=] {
_images.clear();
refreshAll();
2019-08-02 10:52:35 +00:00
}, _lifetime);
2019-08-01 14:13:02 +00:00
}
2019-08-02 18:19:14 +00:00
EmojiPack::~EmojiPack() = default;
bool EmojiPack::add(not_null<HistoryItem*> item) {
if (const auto emoji = item->isolatedEmoji()) {
_items[emoji].emplace(item);
return true;
2019-08-01 21:14:19 +00:00
}
return false;
}
2019-08-02 18:19:14 +00:00
void EmojiPack::remove(not_null<const HistoryItem*> item) {
Expects(item->isIsolatedEmoji());
const auto emoji = item->isolatedEmoji();
2019-08-01 21:14:19 +00:00
const auto i = _items.find(emoji);
Assert(i != end(_items));
const auto j = i->second.find(item);
Assert(j != end(i->second));
i->second.erase(j);
if (i->second.empty()) {
_items.erase(i);
}
}
2019-08-07 14:22:51 +00:00
auto EmojiPack::stickerForEmoji(const IsolatedEmoji &emoji) -> Sticker {
2019-08-02 18:19:14 +00:00
Expects(!emoji.empty());
if (emoji.items[1] != nullptr) {
2019-08-07 14:22:51 +00:00
return Sticker();
}
const auto first = emoji.items[0];
const auto i = _map.find(first);
if (i != end(_map)) {
return { i->second.get(), nullptr };
}
if (!first->colored()) {
return Sticker();
}
const auto j = _map.find(first->original());
if (j != end(_map)) {
const auto index = first->variantIndex(first);
return { j->second.get(), ColorReplacements(index) };
2019-08-01 14:13:02 +00:00
}
2019-08-07 14:22:51 +00:00
return Sticker();
2019-08-01 14:13:02 +00:00
}
2020-05-29 14:29:21 +00:00
std::shared_ptr<LargeEmojiImage> EmojiPack::image(EmojiPtr emoji) {
const auto i = _images.emplace(
emoji,
std::weak_ptr<LargeEmojiImage>()).first;
2019-08-02 18:19:14 +00:00
if (const auto result = i->second.lock()) {
return result;
}
2020-05-29 14:29:21 +00:00
auto result = std::make_shared<LargeEmojiImage>();
const auto raw = result.get();
const auto weak = base::make_weak(_session.get());
raw->load = [=] {
Core::App().emojiImageLoader().with([=](
const EmojiImageLoader &loader) {
2020-05-29 14:29:21 +00:00
crl::on_main(weak, [
=,
image = loader.prepare(emoji)
]() mutable {
const auto i = _images.find(emoji);
if (i != end(_images)) {
if (const auto strong = i->second.lock()) {
if (!strong->image) {
strong->load = nullptr;
2020-05-29 15:10:25 +00:00
strong->image.emplace(std::move(image));
_session->notifyDownloaderTaskFinished();
2020-05-29 14:29:21 +00:00
}
}
}
});
});
raw->load = nullptr;
};
2019-08-02 18:19:14 +00:00
i->second = result;
return result;
}
2021-09-14 16:55:35 +00:00
auto EmojiPack::animationsForEmoji(EmojiPtr emoji) const
-> const base::flat_map<int, not_null<DocumentData*>> & {
static const auto empty = base::flat_map<int, not_null<DocumentData*>>();
const auto i = _animations.find(emoji);
return (i != end(_animations)) ? i->second : empty;
}
std::unique_ptr<Lottie::SinglePlayer> EmojiPack::effectPlayer(
not_null<DocumentData*> document,
QByteArray data,
QString filepath,
bool premium) {
// Shortened copy from stickers_lottie module.
const auto baseKey = document->bigFileBaseCacheKey();
const auto tag = uint8(0);
const auto keyShift = ((tag << 4) & 0xF0)
| (uint8(ChatHelpers::StickerLottieSize::EmojiInteraction) & 0x0F);
const auto key = Storage::Cache::Key{
baseKey.high,
baseKey.low + keyShift
};
const auto get = [=](int i, FnMut<void(QByteArray &&cached)> handler) {
document->owner().cacheBigFile().get(
{ key.high, key.low + i },
std::move(handler));
};
const auto weak = base::make_weak(&document->session());
const auto put = [=](int i, QByteArray &&cached) {
crl::on_main(weak, [=, data = std::move(cached)]() mutable {
weak->data().cacheBigFile().put(
{ key.high, key.low + i },
std::move(data));
});
};
const auto size = premium
? HistoryView::Sticker::PremiumEffectSize(document)
: HistoryView::Sticker::EmojiEffectSize();
const auto request = Lottie::FrameRequest{
size * style::DevicePixelRatio(),
};
auto &weakProvider = _sharedProviders[document];
auto shared = [&] {
if (const auto result = weakProvider.lock()) {
return result;
}
const auto result = Lottie::SinglePlayer::SharedProvider(
premium ? kPremiumCachesCount : kEmojiCachesCount,
get,
put,
Lottie::ReadContent(data, filepath),
request,
Lottie::Quality::High);
weakProvider = result;
return result;
}();
return std::make_unique<Lottie::SinglePlayer>(std::move(shared), request);
}
2019-08-01 14:13:02 +00:00
void EmojiPack::refresh() {
if (_requestId) {
return;
}
_requestId = _session->api().request(MTPmessages_GetStickerSet(
2021-11-19 19:04:40 +00:00
MTP_inputStickerSetAnimatedEmoji(),
MTP_int(0) // hash
2019-08-01 14:13:02 +00:00
)).done([=](const MTPmessages_StickerSet &result) {
2019-08-01 21:14:19 +00:00
_requestId = 0;
2021-09-14 16:55:35 +00:00
refreshAnimations();
2019-08-01 14:13:02 +00:00
result.match([&](const MTPDmessages_stickerSet &data) {
2019-08-01 21:14:19 +00:00
applySet(data);
2021-11-19 19:04:40 +00:00
}, [](const MTPDmessages_stickerSetNotModified &) {
LOG(("API Error: Unexpected messages.stickerSetNotModified."));
2019-08-01 14:13:02 +00:00
});
2021-03-12 12:48:00 +00:00
}).fail([=](const MTP::Error &error) {
2019-08-01 21:14:19 +00:00
_requestId = 0;
2019-08-01 14:13:02 +00:00
refreshDelayed();
}).send();
}
2021-09-14 16:55:35 +00:00
void EmojiPack::refreshAnimations() {
if (_animationsRequestId) {
return;
}
_animationsRequestId = _session->api().request(MTPmessages_GetStickerSet(
2021-11-19 19:04:40 +00:00
MTP_inputStickerSetAnimatedEmojiAnimations(),
MTP_int(0) // hash
2021-09-14 16:55:35 +00:00
)).done([=](const MTPmessages_StickerSet &result) {
_animationsRequestId = 0;
refreshDelayed();
result.match([&](const MTPDmessages_stickerSet &data) {
applyAnimationsSet(data);
2021-11-19 19:04:40 +00:00
}, [](const MTPDmessages_stickerSetNotModified &) {
LOG(("API Error: Unexpected messages.stickerSetNotModified."));
2021-09-14 16:55:35 +00:00
});
}).fail([=] {
2021-09-14 16:55:35 +00:00
_animationsRequestId = 0;
refreshDelayed();
}).send();
}
2019-08-01 21:14:19 +00:00
void EmojiPack::applySet(const MTPDmessages_stickerSet &data) {
const auto stickers = collectStickers(data.vdocuments().v);
auto was = base::take(_map);
for (const auto &pack : data.vpacks().v) {
pack.match([&](const MTPDstickerPack &data) {
applyPack(data, stickers);
});
}
for (const auto &[emoji, document] : _map) {
const auto i = was.find(emoji);
if (i == end(was)) {
refreshItems(emoji);
} else {
if (i->second != document) {
refreshItems(i->first);
}
was.erase(i);
}
}
for (const auto &[emoji, document] : was) {
2019-08-01 21:14:19 +00:00
refreshItems(emoji);
}
}
2021-09-14 16:55:35 +00:00
void EmojiPack::applyAnimationsSet(const MTPDmessages_stickerSet &data) {
const auto stickers = collectStickers(data.vdocuments().v);
const auto &packs = data.vpacks().v;
const auto indices = collectAnimationsIndices(packs);
_animations.clear();
for (const auto &pack : packs) {
pack.match([&](const MTPDstickerPack &data) {
const auto emoticon = qs(data.vemoticon());
if (IndexFromEmoticon(emoticon).has_value()) {
return;
}
const auto emoji = Ui::Emoji::Find(emoticon);
if (!emoji) {
return;
}
for (const auto &id : data.vdocuments().v) {
const auto i = indices.find(id.v);
if (i == end(indices)) {
continue;
}
const auto j = stickers.find(id.v);
if (j == end(stickers)) {
continue;
}
for (const auto index : i->second) {
_animations[emoji].emplace(index, j->second);
}
}
});
}
}
auto EmojiPack::collectAnimationsIndices(
const QVector<MTPStickerPack> &packs
) const -> base::flat_map<uint64, base::flat_set<int>> {
auto result = base::flat_map<uint64, base::flat_set<int>>();
for (const auto &pack : packs) {
pack.match([&](const MTPDstickerPack &data) {
if (const auto index = IndexFromEmoticon(qs(data.vemoticon()))) {
for (const auto &id : data.vdocuments().v) {
result[id.v].emplace(*index);
}
}
});
}
return result;
}
2019-08-02 18:19:14 +00:00
void EmojiPack::refreshAll() {
for (const auto &[emoji, list] : _items) {
refreshItems(list);
}
}
2019-08-01 21:14:19 +00:00
void EmojiPack::refreshItems(EmojiPtr emoji) {
2019-08-02 18:19:14 +00:00
const auto i = _items.find(IsolatedEmoji{ { emoji } });
if (!emoji->colored()) {
if (const auto count = emoji->variantsCount()) {
for (auto i = 0; i != count; ++i) {
refreshItems(emoji->variant(i + 1));
}
}
}
2019-08-01 21:14:19 +00:00
if (i == end(_items)) {
return;
}
2019-08-02 18:19:14 +00:00
refreshItems(i->second);
}
void EmojiPack::refreshItems(
const base::flat_set<not_null<HistoryItem*>> &list) {
for (const auto &item : list) {
2019-08-01 21:14:19 +00:00
_session->data().requestItemViewRefresh(item);
}
}
void EmojiPack::applyPack(
const MTPDstickerPack &data,
const base::flat_map<uint64, not_null<DocumentData*>> &map) {
const auto emoji = [&] {
return Ui::Emoji::Find(qs(data.vemoticon()));
}();
const auto document = [&]() -> DocumentData * {
for (const auto &id : data.vdocuments().v) {
const auto i = map.find(id.v);
if (i != end(map)) {
return i->second.get();
}
}
return nullptr;
}();
if (emoji && document) {
_map.emplace_or_assign(emoji, document);
}
}
base::flat_map<uint64, not_null<DocumentData*>> EmojiPack::collectStickers(
const QVector<MTPDocument> &list) const {
auto result = base::flat_map<uint64, not_null<DocumentData*>>();
for (const auto &sticker : list) {
const auto document = _session->data().processDocument(
sticker);
if (document->sticker()) {
result.emplace(document->id, document);
}
}
return result;
}
2019-08-01 14:13:02 +00:00
void EmojiPack::refreshDelayed() {
base::call_delayed(kRefreshTimeout, _session, [=] {
2019-08-01 14:13:02 +00:00
refresh();
});
}
} // namespace Stickers