Add avatar gallery sources and manifest-aware desktop cache
This commit is contained in:
1 parent
d1b2347b36
commit
4dbda288f0
2 files changed
+99
-22
No files matched your search
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
Reference in new issue
Block a user