Fix merge

Author: leolost2605

src/AudioObject.vala

@@ -5,23 +5,21 @@
 
 public class Music.AudioObject : Object {
     public string uri { get; construct; }
-    public Gdk.Texture? texture { get; set; default = null; }
-    public string album { get; set; }
-    public string artist { get; set; }
-    public string title { get; set; }
-    public int64 duration { get; set; default = 0; }
-    public string art_url { get; set; default = ""; }
+    public Gdk.Texture? texture { get; private set; default = null; }
+    public string album { get; private set; }
+    public string artist { get; private set; }
+    public string title { get; private set; }
+    public int64 duration { get; private set; default = 0; }
+    public string art_url { get; private set; default = ""; }
 
     private static MetadataDiscoverer discoverer = new MetadataDiscoverer ();
 
     public AudioObject (string uri) {
-        Object (
-            uri: uri,
-            title: uri
-        );
+        Object (uri: uri);
     }
 
     construct {
+        title = uri;
         discoverer.request (this);
     }
 
@@ -44,12 +42,29 @@ public class Music.AudioObject : Object {
             artist = _("Unknown");
         }
 
-        var sample = get_cover_sample (tag_list);
-        if (sample != null) {
-            var buffer = sample.get_buffer ();
+        string art_hash = uri;
+        if (_artist != null && _album != null) {
+            art_hash = "%s:%s".printf (_artist, _album);
+        }
 
-            if (buffer != null) {
-                texture = Gdk.Texture.for_pixbuf (get_pixbuf_from_buffer (buffer));
+        var art_file = File.new_for_path (Path.build_path (
+            Path.DIR_SEPARATOR_S,
+            get_art_cache_dir (),
+            Checksum.compute_for_string (SHA256, art_hash)
+        ));
+
+        if (art_file.query_exists ()) {
+            art_url = art_file.get_uri ();
+            texture = Gdk.Texture.from_file (art_file);
+        } else {
+            var sample = get_cover_sample (tag_list);
+            if (sample != null) {
+                var buffer = sample.get_buffer ();
+
+                if (buffer != null) {
+                    texture = Gdk.Texture.for_pixbuf (get_pixbuf_from_buffer (buffer));
+                    save_art_file.begin (texture, art_file);
+                }
             }
         }
     }
@@ -97,6 +112,28 @@ public class Music.AudioObject : Object {
         return pix;
     }
 
+    private async void save_art_file (Gdk.Texture? texture, File file) requires (texture != null) {
+        try {
+            DirUtils.create_with_parents (get_art_cache_dir (), 0755);
+
+            var ostream = yield file.create_async (NONE);
+            yield ostream.write_bytes_async (texture.save_to_png_bytes ());
+
+            art_url = file.get_uri ();
+        } catch (Error e) {
+            critical ("Error saving artwork file: %s", e.message);
+        }
+    }
+
+    private string get_art_cache_dir () {
+        return Path.build_path (
+            Path.DIR_SEPARATOR_S,
+            Environment.get_user_cache_dir (),
+            GLib.Application.get_default ().application_id,
+            "art"
+        );
+    }
+
     public static bool equal_func (AudioObject a, AudioObject b) {
         return (a.uri == b.uri);
     }

src/MetadataDiscoverer.vala

@@ -1,6 +1,11 @@
+/*
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ * SPDX-FileCopyrightText: 2025 elementary, Inc. (https://elementary.io)
+ */
+
 [SingleInstance]
 public class Music.MetadataDiscoverer : Object {
-    private Gst.PbUtils.Discoverer discoverer;
+    private Gst.PbUtils.Discoverer? discoverer;
     private HashTable<string, AudioObject> objects_to_update;
 
     construct {
@@ -11,19 +16,21 @@ public class Music.MetadataDiscoverer : Object {
         } catch (Error e) {
             critical ("Unable to start Gstreamer Discoverer: %s", e.message);
         }
+
         objects_to_update = new HashTable<string, AudioObject> (str_hash, str_equal);
     }
 
-    public void request (AudioObject audio) {
-        objects_to_update.insert (audio.uri, audio);
+    public void request (AudioObject audio) requires (discoverer != null && !objects_to_update.contains (audio.uri)) {
+        objects_to_update[audio.uri] = audio;
         discoverer.start ();
         discoverer.discover_uri_async (audio.uri);
     }
 
     private void relay_metadata (Gst.PbUtils.DiscovererInfo info, Error? err) {
         string uri = info.get_uri ();
-        var audio_obj = objects_to_update.get (uri);
-        objects_to_update.remove (uri);
+
+        var audio_obj = objects_to_update.take (uri, null);
+
         switch (info.get_result ()) {
             case Gst.PbUtils.DiscovererResult.URI_INVALID:
                 critical ("Couldn't read metadata for '%s': invalid URI.", uri);

src/PlaybackManager.vala

@@ -305,4 +305,81 @@ public class Music.PlaybackManager : Object {
         next_action.set_enabled (next_sensitive);
         previous_action.set_enabled (previous_sensitive);
     }
+
+    private void on_items_changed () {
+        has_items = queue_liststore.get_n_items () > 0;
+        shuffle_action.set_enabled (queue_liststore.get_n_items () > 1);
+        update_next_previous_sensitivity ();
+        save_queue ();
+    }
+
+    private void on_audio_changed () {
+        playbin.set_state (Gst.State.NULL);
+        if (current_audio != null) {
+            playbin.uri = current_audio.uri;
+            playbin.set_state (Gst.State.PLAYING);
+        } else {
+            playbin.uri = "";
+            playback_position = 0;
+
+            if (progress_timer != 0) {
+                Source.remove (progress_timer);
+                progress_timer = 0;
+            }
+        }
+
+        update_next_previous_sensitivity ();
+
+        play_pause_action.set_enabled (current_audio != null);
+
+        var uri_last_played = current_audio != null ? current_audio.uri : "";
+        settings.set_string ("uri-last-played", uri_last_played);
+    }
+
+    private void save_queue () {
+        string[] list_uri = new string[queue_liststore.n_items];
+
+        for (var i = 0; i < queue_liststore.n_items; i++) {
+            var item = (Music.AudioObject)queue_liststore.get_item (i);
+            list_uri[i] = item.uri;
+        }
+
+        settings.set_strv ("previous-queue", list_uri);
+    }
+
+    public void restore_queue () {
+        // Restoring the queue overwrites the last played. So we need to retrieve it before taking care of the queue
+        var uri_last_played = settings.get_string ("uri-last-played");
+        var file_last_played = File.new_for_uri (uri_last_played);
+
+        var last_session_uri = settings.get_strv ("previous-queue");
+        if (last_session_uri.length == 0) {
+            return;
+        }
+
+        var last_session_files = new File[last_session_uri.length];
+
+        for (var i = 0; i < last_session_uri.length; i++) {
+            var uri = last_session_uri[i];
+            var file = File.new_for_uri (uri);
+            last_session_files[i] = file;
+        }
+
+        var files_to_play = Application.loop_through_files (last_session_files);
+        queue_files (files_to_play);
+
+        if (uri_last_played != "" && file_last_played.query_exists ()) {
+            var audio_object = new AudioObject (uri_last_played);
+            uint position = -1;
+            if (!queue_liststore.find_with_equal_func (
+                audio_object,
+                (EqualFunc<AudioObject>) AudioObject.equal_func,
+                out position
+            )) {
+                return;
+            }
+
+            current_audio = (AudioObject) queue_liststore.get_item (position);
+        }
+    }
 }