[gnome-music/wip/mschraal/rework-art-widget: 1/12] artcache: Split out media art loading

[Marinus Schraal <mschraal src gnome org>]

commit acd91012a054f7f1a82eb72b7813062e7485dc15
Author: Marinus Schraal <mschraal gnome org>
Date:   Tue Mar 29 22:58:33 2022 +0200

    artcache: Split out media art loading

 gnomemusic/artcache.py       |  49 ++++-----------------
 gnomemusic/mediaartloader.py | 100 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 109 insertions(+), 40 deletions(-)
---
diff --git a/gnomemusic/artcache.py b/gnomemusic/artcache.py
index bb7d9c635..d189fe917 100644
--- a/gnomemusic/artcache.py
+++ b/gnomemusic/artcache.py
@@ -22,11 +22,13 @@
 # code, but you are not obligated to do so.  If you do not wish to do so,
 # delete this exception statement from your version.
 
-from gi.repository import Gdk, GdkPixbuf, Gio, Gtk, GLib, GObject
+from gi.repository import GObject, Gtk
 
+from gnomemusic.asyncqueue import AsyncQueue
 from gnomemusic.coreartist import CoreArtist
 from gnomemusic.coverpaintable import CoverPaintable
 from gnomemusic.defaulticon import DefaultIcon
+from gnomemusic.mediaartloader import MediaArtLoader
 from gnomemusic.musiclogger import MusicLogger
 from gnomemusic.utils import ArtSize, DefaultIconType
 
@@ -44,6 +46,8 @@ class ArtCache(GObject.GObject):
         "finished": (GObject.SignalFlags.RUN_FIRST, None, (object, ))
     }
 
+    _async_queue = AsyncQueue("ArtCache")
+
     _log = MusicLogger()
 
     def __init__(self, widget: Gtk.Widget) -> None:
@@ -80,49 +84,14 @@ class ArtCache(GObject.GObject):
             self.emit("finished", self._paintable)
             return
 
-        thumb_file = Gio.File.new_for_uri(thumbnail_uri)
-        if thumb_file:
-            thumb_file.read_async(
-                GLib.PRIORITY_DEFAULT_IDLE, None, self._open_stream, None)
-            return
-
-        self.emit("finished", self._paintable)
-
-    def _open_stream(self, thumb_file, result, arguments):
-        try:
-            stream = thumb_file.read_finish(result)
-        except GLib.Error as error:
-            self._log.warning(
-                "Error: {}, {}".format(error.domain, error.message))
-            self.emit("finished", self._paintable)
-            return
+        art_loader = MediaArtLoader()
+        art_loader.connect("finished", self._on_art_loading_finished)
+        self._async_queue.queue(art_loader, thumbnail_uri)
 
-        GdkPixbuf.Pixbuf.new_from_stream_async(
-            stream, None, self._pixbuf_loaded, None)
-
-    def _pixbuf_loaded(self, stream, result, data):
-        try:
-            pixbuf = GdkPixbuf.Pixbuf.new_from_stream_finish(result)
-        except GLib.Error as error:
-            self._log.warning(
-                "Error: {}, {}".format(error.domain, error.message))
-            self.emit("finished", self._paintable)
-            return
-
-        texture = Gdk.Texture.new_for_pixbuf(pixbuf)
+    def _on_art_loading_finished(self, art_loader, texture) -> None:
         if texture:
             self._paintable = CoverPaintable(
                 self._size, self._widget, icon_type=self._icon_type,
                 texture=texture)
 
-        stream.close_async(
-            GLib.PRIORITY_DEFAULT_IDLE, None, self._close_stream, None)
-
-    def _close_stream(self, stream, result, data):
-        try:
-            stream.close_finish(result)
-        except GLib.Error as error:
-            self._log.warning(
-                "Error: {}, {}".format(error.domain, error.message))
-
         self.emit("finished", self._paintable)
diff --git a/gnomemusic/mediaartloader.py b/gnomemusic/mediaartloader.py
new file mode 100644
index 000000000..e43c3803c
--- /dev/null
+++ b/gnomemusic/mediaartloader.py
@@ -0,0 +1,100 @@
+# Copyright 2022 The GNOME Music developers
+#
+# GNOME Music is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# GNOME Music is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with GNOME Music; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# The GNOME Music authors hereby grant permission for non-GPL compatible
+# GStreamer plugins to be used and distributed together with GStreamer
+# and GNOME Music.  This permission is above and beyond the permissions
+# granted by the GPL license by which GNOME Music is covered.  If you
+# modify this code, you may extend this exception to your version of the
+# code, but you are not obligated to do so.  If you do not wish to do so,
+# delete this exception statement from your version.
+
+from __future__ import annotations
+from typing import Any
+
+from gi.repository import Gdk, GdkPixbuf, Gio, GLib, GObject
+
+from gnomemusic.musiclogger import MusicLogger
+
+
+class MediaArtLoader(GObject.GObject):
+    """Handles retrieval of MediaArt cache art
+    """
+
+    __gtype_name__ = "MediaArtLoader"
+
+    __gsignals__ = {
+        "finished": (GObject.SignalFlags.RUN_FIRST, None, (object, ))
+    }
+
+    _log = MusicLogger()
+
+    def __init__(self) -> None:
+        """Intialize MediaArtLoader
+        """
+        super().__init__()
+
+        self._texture = None
+
+    def start(self, uri: str) -> None:
+        """Start the cache query
+
+        :param str uri: The MediaArt uri
+        """
+        thumb_file = Gio.File.new_for_uri(uri)
+
+        if thumb_file:
+            thumb_file.read_async(
+                GLib.PRIORITY_DEFAULT_IDLE, None, self._open_stream, None)
+        else:
+            self.emit("finished", None)
+
+    def _open_stream(
+            self, thumb_file: Gio.File, result: Gio.AsyncResult,
+            arguments: Any) -> None:
+        try:
+            stream = thumb_file.read_finish(result)
+        except GLib.Error as error:
+            self._log.warning(
+                "Error: {}, {}".format(error.domain, error.message))
+            self.emit("finished", None)
+            return
+
+        GdkPixbuf.Pixbuf.new_from_stream_async(
+            stream, None, self._pixbuf_loaded, None)
+
+    def _pixbuf_loaded(self, stream, result, data):
+        try:
+            pixbuf = GdkPixbuf.Pixbuf.new_from_stream_finish(result)
+        except GLib.Error as error:
+            self._log.warning(
+                "Error: {}, {}".format(error.domain, error.message))
+            self.emit("finished", None)
+            return
+
+        self._texture = Gdk.Texture.new_for_pixbuf(pixbuf)
+
+        stream.close_async(
+            GLib.PRIORITY_DEFAULT_IDLE, None, self._close_stream, None)
+
+    def _close_stream(self, stream, result, data):
+        try:
+            stream.close_finish(result)
+        except GLib.Error as error:
+            self._log.warning(
+                "Error: {}, {}".format(error.domain, error.message))
+
+        self.emit("finished", self._texture)