Merge branch 'fix-crash-on-close'

This commit is contained in:
ItsLemmy
2025-11-29 09:39:05 -05:00
5 changed files with 597 additions and 75 deletions
+296
View File
@@ -18,6 +18,17 @@ Singleton {
property string latestVersion: I18n.tr("system.unknown-version")
property var contributors: []
// Avatar caching properties
property var cachedCircularAvatars: ({}) // username → file:// path
property var cacheMetadata: ({}) // Loaded from metadata.json
property var avatarQueue: []
property bool isProcessingAvatars: false
property bool metadataLoaded: false
property bool avatarsCached: false // Track if we've already processed avatars
readonly property string avatarCacheDir: Settings.cacheDirImages + "contributors/"
readonly property string metadataPath: avatarCacheDir + "metadata.json"
FileView {
id: githubDataFileView
path: githubDataFile
@@ -25,6 +36,7 @@ Singleton {
onFileChanged: reload()
onAdapterUpdated: writeAdapter()
Component.onCompleted: {
loadCacheMetadata();
reload();
}
onLoaded: {
@@ -48,6 +60,12 @@ Singleton {
}
}
// --------------------------------
function init() {
Logger.i("GitHub", "Service started");
loadFromCache();
}
// --------------------------------
function loadFromCache() {
const now = Time.timestamp;
@@ -118,6 +136,284 @@ Singleton {
fetchFromGitHub();
}
// --------------------------------
// Avatar Caching Functions
// --------------------------------
function loadCacheMetadata() {
var loadProcess = Qt.createQmlObject(`
import QtQuick
import Quickshell.Io
Process {
command: ["cat", "${metadataPath}"]
}
`, root, "LoadMetadata");
loadProcess.stdout = Qt.createQmlObject(`
import QtQuick
import Quickshell.Io
StdioCollector {}
`, loadProcess, "StdoutCollector");
loadProcess.stdout.onStreamFinished.connect(function () {
try {
var text = loadProcess.stdout.text;
if (text && text.trim()) {
cacheMetadata = JSON.parse(text);
Logger.d("GitHubService", "Loaded cache metadata:", Object.keys(cacheMetadata).length, "entries");
// Populate cachedCircularAvatars from metadata
for (var username in cacheMetadata) {
var entry = cacheMetadata[username];
cachedCircularAvatars[username] = "file://" + entry.cached_path;
}
metadataLoaded = true;
Logger.d("GitHubService", "Cache metadata loaded successfully");
} else {
Logger.d("GitHubService", "No existing cache metadata found (empty response)");
cacheMetadata = {};
metadataLoaded = true;
}
} catch (e) {
Logger.w("GitHubService", "Failed to parse cache metadata:", e);
cacheMetadata = {};
metadataLoaded = true;
}
loadProcess.destroy();
});
loadProcess.exited.connect(function (exitCode) {
if (exitCode !== 0) {
// File doesn't exist, initialize empty
cacheMetadata = {};
metadataLoaded = true;
Logger.d("GitHubService", "Initializing empty cache metadata");
}
});
loadProcess.running = true;
}
function saveCacheMetadata() {
Quickshell.execDetached(["mkdir", "-p", avatarCacheDir]);
var jsonContent = JSON.stringify(cacheMetadata, null, 2);
// Use printf with base64 encoding to safely handle special characters
var base64Content = Qt.btoa(jsonContent); // Base64 encode
var saveProcess = Qt.createQmlObject(`
import QtQuick
import Quickshell.Io
Process {
command: ["sh", "-c", "echo '${base64Content}' | base64 -d > '${metadataPath}'"]
}
`, root, "SaveMetadata_" + Date.now());
saveProcess.exited.connect(function (exitCode) {
if (exitCode === 0) {
Logger.d("GitHubService", "Saved cache metadata");
} else {
Logger.e("GitHubService", "Failed to save cache metadata, exit code:", exitCode);
}
saveProcess.destroy();
});
saveProcess.running = true;
}
function cacheTopContributorAvatars() {
if (contributors.length === 0)
return;
// Mark that we've processed avatars for this contributor set
avatarsCached = true;
Quickshell.execDetached(["mkdir", "-p", avatarCacheDir]);
// Build queue of avatars that need processing
avatarQueue = [];
var currentTop20 = {};
for (var i = 0; i < Math.min(contributors.length, 20); i++) {
var contributor = contributors[i];
var username = contributor.login;
var avatarUrl = contributor.avatar_url;
var circularPath = avatarCacheDir + username + "_circular.png";
currentTop20[username] = true;
// Check if we need to process this avatar
var needsProcessing = false;
var reason = "";
if (!cacheMetadata[username]) {
// New user in top 20
needsProcessing = true;
reason = "new user";
} else if (cacheMetadata[username].avatar_url !== avatarUrl) {
// Avatar URL changed (user updated their GitHub avatar)
needsProcessing = true;
reason = "avatar URL changed";
} else {
// Already cached - add to map
cachedCircularAvatars[username] = "file://" + circularPath;
}
if (needsProcessing) {
Logger.d("GitHubService", "Queueing avatar for", username, "-", reason);
avatarQueue.push({
username: username,
avatarUrl: avatarUrl,
circularPath: circularPath
});
}
}
// Cleanup: Remove metadata for users no longer in top 20
var removedUsers = [];
for (var cachedUsername in cacheMetadata) {
if (!currentTop20[cachedUsername]) {
removedUsers.push(cachedUsername);
// Delete cached circular file
var pathToDelete = cacheMetadata[cachedUsername].cached_path;
Quickshell.execDetached(["rm", "-f", pathToDelete]);
delete cacheMetadata[cachedUsername];
delete cachedCircularAvatars[cachedUsername];
}
}
if (removedUsers.length > 0) {
Logger.d("GitHubService", "Cleaned up avatars for users no longer in top 20:", removedUsers.join(", "));
saveCacheMetadata();
}
// Start processing queue
if (avatarQueue.length > 0) {
Logger.i("GitHubService", "Processing", avatarQueue.length, "avatar(s)");
processNextAvatar();
} else {
Logger.d("GitHubService", "All avatars already cached");
cachedCircularAvatarsChanged(); // Notify AboutTab
}
}
function processNextAvatar() {
if (avatarQueue.length === 0 || isProcessingAvatars)
return;
isProcessingAvatars = true;
var item = avatarQueue.shift();
Logger.d("GitHubService", "Downloading avatar for", item.username);
// Download original avatar
var tempPath = avatarCacheDir + item.username + "_temp.png";
downloadAvatar(item.avatarUrl, tempPath, function (success) {
if (success) {
// Render circular version
renderCircularAvatar(tempPath, item.circularPath, item.username, item.avatarUrl);
} else {
Logger.e("GitHubService", "Failed to download avatar for", item.username);
isProcessingAvatars = false;
processNextAvatar();
}
});
}
function downloadAvatar(url, destPath, callback) {
var downloadCmd = `curl -L -s -o '${destPath}' '${url}' || wget -q -O '${destPath}' '${url}'`;
var downloadProcess = Qt.createQmlObject(`
import QtQuick
import Quickshell.Io
Process {
command: ["sh", "-c", "${downloadCmd}"]
}
`, root, "Download_" + Date.now());
downloadProcess.exited.connect(function (exitCode) {
callback(exitCode === 0);
downloadProcess.destroy();
});
downloadProcess.running = true;
}
function renderCircularAvatar(inputPath, outputPath, username, avatarUrl) {
var rendererComponent = Qt.createComponent(Quickshell.shellDir + "/Modules/Renderer/CircularAvatarRenderer.qml");
if (rendererComponent.status === Component.Ready) {
var renderer = rendererComponent.createObject(root, {
imagePath: "file://" + inputPath,
outputPath: outputPath,
username: username
});
renderer.renderComplete.connect(function (success) {
if (success) {
// Update cache metadata
cacheMetadata[username] = {
avatar_url: avatarUrl,
cached_path: outputPath,
cached_at: Date.now()
};
cachedCircularAvatars[username] = "file://" + outputPath;
cachedCircularAvatarsChanged();
saveCacheMetadata();
Logger.d("GitHubService", "Cached circular avatar for", username);
} else {
Logger.e("GitHubService", "Failed to render circular avatar for", username);
}
renderer.destroy();
// Clean up temp file
Quickshell.execDetached(["rm", "-f", inputPath]);
// Process next in queue
isProcessingAvatars = false;
processNextAvatar();
});
} else {
Logger.e("GitHubService", "Failed to create CircularAvatarRenderer");
isProcessingAvatars = false;
processNextAvatar();
}
}
// --------------------------------
// Hook into contributors change - only process once
onContributorsChanged: {
if (contributors.length > 0 && !avatarsCached) {
// Wait for metadata to load before processing
if (metadataLoaded) {
Qt.callLater(cacheTopContributorAvatars);
} else {
// Metadata not loaded yet, wait for it
metadataLoadedWatcher.start();
}
}
}
// Wait for metadata to be loaded before caching avatars
Timer {
id: metadataLoadedWatcher
interval: 100
repeat: true
onTriggered: {
if (metadataLoaded && contributors.length > 0 && !avatarsCached) {
stop();
Qt.callLater(cacheTopContributorAvatars);
}
}
}
Process {
id: versionProcess