Add avatar gallery sources and manifest-aware desktop cache

This commit is contained in:
evgeny committed 2026-10-06 19:33:24 +02:00
1 parent d1b2347b36
commit 4dbda288f0
2 files changed
+99 -22

No files matched your search

+77 -19
View File
@@ -5,6 +5,7 @@
#include <QDateTime>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QMetaObject>
#include <QRandomGenerator>
#include <QRunnable>
@@ -53,7 +54,7 @@ void AvatarManager::initialize() {
if (desired != "-" && !desired.isEmpty()) {
const auto parts = desired.split('/');
bool valid = false; quint64 server = parts[0].toULongLong(&valid, 16);
if (parts.size() == 2 && valid && server && mf_avatar_file_valid(parts[1].toLatin1().constData())) {
if (parts.size() == 2 && valid && server && mf_avatar_manifest_valid(parts[1].toLatin1().constData())) {
m_defaultServer = server; m_defaultHash = parts[1].left(64);
} else {
DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "avatar: invalid saved default reference"); m_defaultConfigured = false;
@@ -101,7 +102,7 @@ void AvatarManager::onMembers(const QString& channel, int count, const uint8_t*
if (member.storage_role) m_servers[group][member.node_id] = QString::fromUtf8(member.name);
else m_servers[group].remove(member.node_id);
Ref ref{group, member.node_id, member.avatar_server, QString::fromLatin1(member.avatar_file).left(64)};
if (!ref.server || !mf_avatar_file_valid(member.avatar_file)) { ref.server = 0; ref.hash.clear(); }
if (!ref.server || !mf_avatar_manifest_valid(member.avatar_file)) { ref.server = 0; ref.hash.clear(); }
const Ref old = m_refs.value(context); m_refs[context] = ref;
if (old.hash != ref.hash || old.server != ref.server) {
referencesChanged = true;
@@ -141,10 +142,56 @@ QImage AvatarManager::image(const QString& channel, quint64 owner) {
const QString context = key(channel.toULongLong(), owner); const Ref ref = m_refs.value(context);
if (!m_ready || !ref.server || ref.hash.isEmpty()) return {};
m_wanted.insert(context);
if (auto* image = m_images.object(ref.hash)) return *image;
if (!m_missing.contains(ref.hash)) { loadCache(ref.hash); return {}; }
if (m_retry.value(context) > QDateTime::currentMSecsSinceEpoch()) return {};
Job job; job.ref = ref; enqueue(job); pump(); return {};
return fetch(ref, false, false);
}
QImage AvatarManager::fetch(const Ref& ref, bool original, bool gallery) {
const QString cacheKey = ref.hash + (original ? ":original" : "");
if (auto* image = m_images.object(cacheKey)) return *image;
if (!m_missing.contains(cacheKey)) { loadCache(ref.hash, original); return {}; }
if (m_retry.value(cacheKey) > QDateTime::currentMSecsSinceEpoch()) return {};
if (!m_servers.value(ref.group).contains(ref.server)) return {};
Job job; job.ref = ref; job.original = original; job.gallery = gallery; job.generation = m_generation;
const auto record = m_records.value(ref.hash);
job.file = record.original.isEmpty() ? ref.hash + ".json" : (original ? record.original : record.preview);
enqueue(job); pump(); return {};
}
void AvatarManager::openGallery(const QString& channel, quint64 owner) {
closeGallery(); m_galleryRef = m_refs.value(key(channel.toULongLong(), owner));
if (!channel.toULongLong()) for (const auto& ref : m_refs) if (ref.owner == owner && ref.server &&
(!m_galleryRef.group || ref.group < m_galleryRef.group)) m_galleryRef = ref;
if (!m_galleryRef.server || m_galleryRef.hash.isEmpty()) { emit galleryError(text("No avatar")); return; }
m_gallery = {m_galleryRef.hash}; emit galleryChanged(); listGallery();
DEBUG_INFO(DEBUG_CATEGORY_MEDIA, "avatar: gallery opened group=%llu owner=%016llx server=%016llx",
(unsigned long long)m_galleryRef.group, (unsigned long long)owner, (unsigned long long)m_galleryRef.server);
}
void AvatarManager::closeGallery() {
if (m_listId && gui_bridge_is_uasync_ready()) {
auto* q = (mf_cancel_request*)u_calloc(1, sizeof(mf_cancel_request));
if (q) { q->inst = gui_bridge_get_inst(); q->id = m_listId; gui_bridge_post_uasync_fn(member_files_gui_cancel, q); }
else DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "avatar: gallery cancel allocation failed");
}
m_listId = 0; m_galleryRef = {}; m_gallery.clear(); m_catalog.clear(); m_listRetries = 0;
QQueue<Job> keep; while (!m_queue.isEmpty()) { const auto job = m_queue.dequeue(); if (!job.gallery) keep.enqueue(job); }
m_queue = keep;
}
void AvatarManager::listGallery(quint64 cursor, const QByteArray& version) {
auto* q = (mf_gui_request*)u_calloc(1, sizeof(mf_gui_request));
if (!q) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "avatar: catalog allocation failed"); emit galleryError(text("Cannot load avatars")); return; }
do { m_listId = QRandomGenerator::global()->generate64(); } while (!m_listId || m_jobs.contains(m_listId));
q->inst = gui_bridge_get_inst(); q->group = m_galleryRef.group; q->server = m_galleryRef.server;
q->message.kind = MF_REQUEST; q->message.command = MF_LIST; q->message.request_id = m_listId;
q->message.owner = m_galleryRef.owner; q->message.cursor = cursor; memcpy(q->message.path, "avatars", 8);
if (version.size() == 16) memcpy(q->message.version, version.constData(), 16);
gui_bridge_post_uasync_fn(member_files_gui_request, q);
}
QImage AvatarManager::galleryImage(const QString& hash, bool original) {
if (!m_galleryRef.server || !m_gallery.contains(hash)) return {};
Ref ref = m_galleryRef; ref.hash = hash; return fetch(ref, original, true);
}
QImage AvatarManager::defaultImage() const {
@@ -154,23 +201,30 @@ QImage AvatarManager::defaultImage() const {
void AvatarManager::notify(const QString& hash) {
for (const auto& ref : m_refs) if (ref.hash == hash) emit changed(QString::number(ref.group), ref.owner);
emit serversChanged();
if (m_gallery.contains(hash)) emit galleryChanged();
}
void AvatarManager::loadCache(const QString& hash) {
if (m_loading.contains(hash)) return;
m_loading.insert(hash); const QString path = m_directory + '/' + hash + QStringLiteral(".png");
m_pool.start(QRunnable::create([this, hash, path] {
void AvatarManager::loadCache(const QString& hash, bool original) {
const QString cacheKey = hash + (original ? ":original" : "");
if (m_loading.contains(cacheKey)) return;
m_loading.insert(cacheKey); const QString path = m_directory + '/' + hash + QStringLiteral(".json");
m_pool.start(QRunnable::create([this, hash, path, cacheKey, original] {
AvatarCache::Result result = AvatarCache::load(path, hash);
if (result.image.isNull() && QFile::exists(path)) {
if (original && !result.record.original.isEmpty()) {
auto full = AvatarCache::readObject(QFileInfo(path).absolutePath() + '/' + result.record.original, result.record.original);
result.image = full.image; result.error = full.error;
}
if (!result.error.isEmpty() && result.record.original.isEmpty() && QFile::exists(path)) {
DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "avatar: invalid cached image hash=%s reason=%s", qPrintable(hash), qPrintable(result.error));
if (!QFile::remove(path)) DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "avatar: cannot remove invalid cache hash=%s", qPrintable(hash));
}
QMetaObject::invokeMethod(this, [this, hash, result] {
m_loading.remove(hash);
if (result.image.isNull()) m_missing.insert(hash);
QMetaObject::invokeMethod(this, [this, hash, cacheKey, result] {
m_loading.remove(cacheKey);
if (!result.record.original.isEmpty()) m_records[hash] = result.record;
if (result.image.isNull()) m_missing.insert(cacheKey);
else {
DEBUG_DEBUG(DEBUG_CATEGORY_MEDIA, "avatar: disk cache hit hash=%s", qPrintable(hash));
m_images.insert(hash, new QImage(result.image), qMax(1, int(result.image.sizeInBytes() / 1024))); m_missing.remove(hash);
m_images.insert(cacheKey, new QImage(result.image), qMax(1, int(result.image.sizeInBytes() / 1024))); m_missing.remove(cacheKey);
}
notify(hash);
}, Qt::QueuedConnection);
@@ -182,20 +236,20 @@ void AvatarManager::saveDefault() {
auto* q = (save_ui_state_arg*)u_calloc(1, sizeof(save_ui_state_arg));
if (!q) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "avatar: preference allocation failed"); return; }
q->inst = gui_bridge_get_inst();
const QByteArray value = m_defaultServer ? (QString::number(m_defaultServer, 16) + '/' + m_defaultHash + ".png").toLatin1() : QByteArray("-");
const QByteArray value = m_defaultServer ? (QString::number(m_defaultServer, 16) + '/' + m_defaultHash + ".json").toLatin1() : QByteArray("-");
const char name[] = "avatar_default";
memcpy(q->data, name, sizeof(name)); memcpy(q->data + sizeof(name), value.constData(), value.size());
gui_bridge_post_uasync_fn(chat_core_save_ui_state_trampoline, q);
}
void AvatarManager::uploadDefault(const QString& source, quint64 server) {
void AvatarManager::uploadDefault(const QString& source, quint64 server, const QRectF& crop) {
if (!m_ready || m_preparing || !server || !gui_bridge_is_uasync_ready()) return;
m_preparing = true; emit statusChanged(text("Preparing avatar…"));
const QString directory = m_directory; const quint64 generation = ++m_generation; cancelUploads();
QStringList pinned; if (!m_defaultHash.isEmpty()) pinned << m_defaultHash;
for (const auto& job : m_jobs) if (job.upload) pinned << job.ref.hash;
m_pool.start(QRunnable::create([this, source, directory, server, generation, pinned] {
const auto result = AvatarCache::prepare(source, directory);
m_pool.start(QRunnable::create([this, source, directory, server, generation, pinned, crop] {
const auto result = AvatarCache::prepare(source, directory, crop);
if (!result.image.isNull()) { auto keep = pinned; keep << result.hash; AvatarCache::prune(directory, keep); }
QMetaObject::invokeMethod(this, [this, result, server, generation] {
m_preparing = false;
@@ -205,6 +259,7 @@ void AvatarManager::uploadDefault(const QString& source, quint64 server) {
emit statusChanged(text("Cannot prepare avatar: %1").arg(result.error)); return;
}
m_defaultHash = result.hash; m_defaultServer = server; saveDefault();
m_records[result.hash] = result.record;
m_images.insert(result.hash, new QImage(result.image), qMax(1, int(result.image.sizeInBytes() / 1024)));
m_missing.remove(result.hash); emit serversChanged(); emit statusChanged(text("Uploading avatar…"));
for (auto group : m_servers.keys()) { m_retry.remove(key(group, m_db->myNodeId())); scheduleOwn(group); }
@@ -244,6 +299,9 @@ void AvatarManager::scheduleOwn(quint64 group) {
const Ref old = m_refs.value(context);
if (old.server == m_defaultServer && old.hash == m_defaultHash) return;
Job job; job.ref = {group, m_db->myNodeId(), m_defaultServer, m_defaultHash}; job.upload = true; job.generation = m_generation;
const auto record = m_records.value(m_defaultHash);
if (record.original.isEmpty()) return;
job.files = {record.original, record.preview, m_defaultHash + ".json"}; job.file = job.files.first();
enqueue(job);
}
+22 -3
View File
@@ -26,7 +26,12 @@ public:
void onPublished(const uint8_t* data, int length);
QImage image(const QString& channel, quint64 owner);
QMap<quint64, QString> servers() const;
void uploadDefault(const QString& source, quint64 server);
void uploadDefault(const QString& source, quint64 server, const QRectF& crop = {});
void openGallery(const QString& channel, quint64 owner);
void closeGallery();
QStringList gallery() const { return m_gallery; }
QString galleryCurrent() const { return m_galleryRef.hash; }
QImage galleryImage(const QString& hash, bool original = false);
void clearDefault();
QImage defaultImage() const;
quint64 defaultServer() const { return m_defaultServer; }
@@ -35,11 +40,19 @@ signals:
void changed(const QString& channel, quint64 owner);
void serversChanged();
void statusChanged(const QString& status);
void galleryChanged();
void galleryError(const QString& error);
private:
struct Ref { quint64 group = 0, owner = 0, server = 0; QString hash; };
struct Job { Ref ref; quint64 id = 0, generation = 0; bool upload = false; int stage = 0; QString local; };
struct Job {
Ref ref; quint64 id = 0, generation = 0; bool upload = false, original = false, gallery = false;
int stage = 0, object = 0; QString local, file; QStringList files;
};
static QString key(quint64 group, quint64 owner);
void loadCache(const QString& hash);
void loadCache(const QString& hash, bool original = false);
QImage fetch(const Ref& ref, bool original, bool gallery);
void nextUpload(Job& job);
void listGallery(quint64 cursor = 0, const QByteArray& version = {});
void notify(const QString& hash);
void scheduleOwn(quint64 group);
void enqueue(const Job& job);
@@ -62,6 +75,12 @@ private:
QHash<QString, unsigned> m_failures;
QQueue<Job> m_queue;
QHash<quint64, Job> m_jobs;
QHash<QString, AvatarCache::Record> m_records;
Ref m_galleryRef;
QStringList m_gallery;
QMap<QString, quint64> m_catalog;
quint64 m_listId = 0;
unsigned m_listRetries = 0;
QThreadPool m_pool;
QTimer m_timer;
};