Merge lp:~elementary-apps/noise/async-pixbuf-cache into lp:~elementary-apps/noise/trunk

[Victor Martinez]

This branch should fix bug #1060122: noise crashed while re-scanning Music folder.

Previously, the code used synchronous (i.e. blocking) I/O to load the cached images from disk, and was run from a different thread to avoid freezing the UI. Since we run into many thread-safety issues, and considering there's not enough time to hunt them down one by one, using Idle calls seems to be the most reliable and quick solution to the problem; the code now uses GLib's Idle scheduler to avoid the need of a second thread here.

Also updates:
+ Last.fm plugin (no longer uses threads.)

Opinions and testers are welcome!

[lp:~elementary-apps/noise/async-pixbuf-cache]

1055. By Victor Martinez on 2012-10-05

[CMake] Fix libnotify support

This revision adds back notification support. Recent changes to the CMake files introduced a bug that would override the HAVE_LIBNOTIFY option, since the default options were being set below in the same file. Enjoy the notifications again.

1056. By Victor Martinez on 2012-10-05

Opps. Search is smart again.

Fix a regression from revision 1049 that would make the searches fail if the search string contained any whitespace character.

1057. By Victor Martinez on 2012-10-05

Merge translations

1058. By David Gomes on 2012-10-06

Small code fixes.

1059. By Victor Martinez on 2012-10-06

CoverartCache.lookup_folder_image_async: rv => image_file

[David Gomes (davidgomes)]

Good branch, GStreamerTagger.vala needs some work, but I can do it tomorrow.

review: Approve

=== modified file 'core/Utils/FileUtils.vala'
--- core/Utils/FileUtils.vala	2012-09-17 22:14:19 +0000
+++ core/Utils/FileUtils.vala	2012-10-06 03:24:21 +0000
@@ -46,6 +46,26 @@
     }
 
     /**
+     * Asynchronously checks whether a file exists or not.
+     * It follows symbolic links.
+     */
+    public async bool query_exists_async (File file_or_dir, Cancellable? cancellable = null) {
+        FileInfo? info = null;
+
+        try {
+            info = yield file_or_dir.query_info_async (FileAttribute.STANDARD_NAME,
+                                                       FileQueryInfoFlags.NONE,
+                                                       Priority.DEFAULT,
+                                                       cancellable);
+        } catch (Error err) {
+            if (err is IOError.NOT_FOUND)
+                return false;
+        }
+
+        return info != null;
+    }
+
+    /**
      * Convenience method to get the size of a file or directory (recursively)
      *
      * @param file a {@link GLib.File} representing the file or directory to be queried
@@ -53,12 +73,12 @@
      * @return size in bytes of file. It is recommended to use GLib.format_size() in case
      *         you want to convert it to a string representation.
      */
-    public uint64 get_size (File file_or_dir, Cancellable? cancellable = null) {
+    public async uint64 get_size_async (File file_or_dir, Cancellable? cancellable = null) {
         uint64 size = 0;
         Gee.Collection<File> files;
 
-        if (is_directory (file_or_dir, cancellable)) {
-            enumerate_files (file_or_dir, null, true, out files, cancellable);
+        if (yield is_directory_async (file_or_dir, cancellable)) {
+            yield enumerate_files_async (file_or_dir, null, true, out files, cancellable);
         } else {
             files = new Gee.LinkedList<File> ();
             files.add (file_or_dir);
@@ -69,8 +89,10 @@
                 break;
 
             try {
-                var info = file.query_info (FileAttribute.STANDARD_SIZE,
-                                            FileQueryInfoFlags.NOFOLLOW_SYMLINKS, cancellable);
+                var info = yield file.query_info_async (FileAttribute.STANDARD_SIZE,
+                                                        FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+                                                        Priority.DEFAULT,
+                                                        cancellable);
                 size += info.get_attribute_uint64 (FileAttribute.STANDARD_SIZE);
             } catch (Error err) {
                 warning ("Could not get size of '%s': %s", file.get_uri (), err.message);
@@ -80,9 +102,23 @@
         return size;
     }
 
-    public bool is_directory (File file, Cancellable? cancellable = null) {
-        var type = file.query_file_type (FileQueryInfoFlags.NOFOLLOW_SYMLINKS, cancellable);
-        return type == FileType.DIRECTORY;
+    /**
+     * Checks whether //dir// is a directory.
+     * Does not follow symbolic links.
+     */
+    public async bool is_directory_async (File dir, Cancellable? cancellable = null) {
+        FileInfo? info = null;
+
+        try {
+            info = yield dir.query_info_async (FileAttribute.STANDARD_TYPE,
+                                               FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+                                               Priority.DEFAULT,
+                                               cancellable);
+        } catch (Error err) {
+            warning (err.message);
+        }
+
+        return info != null && info.get_file_type () == FileType.DIRECTORY;
     }
 
     /**
@@ -90,24 +126,25 @@
      *
      * @param folder a {@link GLib.File} representing the folder you wish to query
      * @param types a string array containing the formats you want to limit the search to, or null
-     *              to allow any file type. e.g. [[[string[] types = {"mp3", "jpg"}]]] [allow-none]
+     *              to allow any file type. e.g. string[] types = {"mp3", "jpg"} [allow-none]
      * @param recursive whether to query the whole directory tree or only immediate children. [allow-none]
      * @param files the data container for the files found. This only includes files, not directories [allow-none]
-     * @param cancellable a cancellable object for cancelling the operation. [allow-none]
+     * @param cancellable a cancellable object for canceling the operation. [allow-none]
      *
      * @return total number of files found (should be the same as files.size)
      */
-    public uint enumerate_files (File folder, string[]? types = null,
-                                 bool recursive = true,
-                                 out Gee.Collection<File>? files = null,
-                                 Cancellable? cancellable = null) {
-        return_val_if_fail (is_directory (folder), 0);
+    public async uint enumerate_files_async (File folder, string[]? types = null,
+                                             bool recursive = true,
+                                             out Gee.Collection<File>? files = null,
+                                             Cancellable? cancellable = null)
+    {
+        return_val_if_fail (yield is_directory_async (folder), 0);
         var counter = new FileEnumerator ();
-        return counter.enumerate_files (folder, types, out files, recursive, cancellable);
+        return yield counter.enumerate_files_async (folder, types, out files, recursive, cancellable);
     }
 
     /**
-     * Comprobates whether a filename matches a given extension.
+     * Queries whether a filename matches a given extension.
      *
      * @param name path, URI or name of the file to verify
      * @param types a string array containing the expected file extensions (without dot).
@@ -143,17 +180,18 @@
          * the directories descendant from folder. In case you only want the first-level
          * descendants, set recursive to false.
          */
-        public uint enumerate_files (File folder, string[]? types,
-                                     out Gee.Collection<File>? files,
-                                     bool recursive = true,
-                                     Cancellable? cancellable = null) {
+        public async uint enumerate_files_async (File folder, string[]? types,
+                                                 out Gee.Collection<File>? files,
+                                                 bool recursive = true,
+                                                 Cancellable? cancellable = null)
+        {
             assert (file_count == 0);
 
             this.types = types;
             this.cancellable = cancellable;
 
             files = new Gee.LinkedList<File> ();
-            enumerate_files_internal (folder, ref files, recursive);
+            yield enumerate_files_internal_async (folder, files, recursive);
             return file_count;
         }
 
@@ -161,19 +199,25 @@
             return Utils.is_cancelled (cancellable);
         }
 
-        private void enumerate_files_internal (File folder, ref Gee.Collection<File>? files,
-            bool recursive) {
-
+        private async void enumerate_files_internal_async (File folder, Gee.Collection<File>? files,
+                                                           bool recursive)
+        {
             if (is_cancelled ())
                 return;
 
             try {
-                var enumerator = folder.enumerate_children (ATTRIBUTES,
-                    FileQueryInfoFlags.NOFOLLOW_SYMLINKS, cancellable);
-
-                FileInfo? file_info = null;
-
-                while ((file_info = enumerator.next_file ()) != null && !is_cancelled ()) {
+                var enumerator = yield folder.enumerate_children_async (ATTRIBUTES,
+                                                                        FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+                                                                        Priority.DEFAULT,
+                                                                        cancellable);
+
+                while (!is_cancelled ()) {
+                    var enum_files = yield enumerator.next_files_async (1, Priority.DEFAULT, cancellable);
+                    FileInfo? file_info = enum_files.nth_data (0);
+
+                    if (file_info == null)
+                        break;
+
                     var file_name = file_info.get_name ();
                     var file_type = file_info.get_file_type ();
                     var file = folder.get_child (file_name);
@@ -183,15 +227,14 @@
                             continue;
 
 	                    file_count++;
+
                         if (files != null)
     	                    files.add (file);
-                    }
-                    else if (recursive && file_type == FileType.DIRECTORY) {
-	                    enumerate_files_internal (file, ref files, true);
+                    } else if (recursive && file_type == FileType.DIRECTORY) {
+	                    yield enumerate_files_internal_async (file, files, true);
                     }
                 }
-            }
-            catch (Error err) {
+            } catch (Error err) {
                 warning ("Could not scan folder: %s", err.message);
             }
         }

=== modified file 'plugins/LastFM/Core.vala'
--- plugins/LastFM/Core.vala	2012-09-18 10:14:54 +0000
+++ plugins/LastFM/Core.vala	2012-10-06 03:24:21 +0000
@@ -40,26 +40,26 @@
         public Settings lastfm_settings { get; private set; }
 
         public string token;
-        
+
         public signal void logged_in();
         public signal void similar_retrieved(LinkedList<int> similarIDs, LinkedList<Noise.Media> similarDont);
-        
+
         LastFM.SimilarMedias similarMedias;
-        
+
         Mutex _artists_lock;
         Mutex _albums_lock;
         Mutex _tracks_lock;
         HashMap<string, LastFM.ArtistInfo> _artists;//key:artist
         HashMap<string, LastFM.AlbumInfo> _albums;//key:artist<sep>album
         HashMap<string, LastFM.TrackInfo> _tracks;//key:artist<sep>album<sep>track
-        
+
         public Core(Noise.LibraryManager lmm) {
             lm = lmm;
-            
+
             lastfm_settings = new LastFM.Settings ();
-            
+
             similarMedias = new LastFM.SimilarMedias(lm);
-            
+
             _artists = new HashMap<string, LastFM.ArtistInfo>();
             _albums = new HashMap<string, LastFM.AlbumInfo>();
             _tracks = new HashMap<string, LastFM.TrackInfo>();
@@ -69,13 +69,13 @@
                 _artists.set(a.name, (LastFM.ArtistInfo)a);
             }
             _artists_lock.unlock();
-            
+
             _albums_lock.lock();
             foreach(Noise.AlbumInfo a in lm.dbm.load_albums()) {
                 _albums.set(a.name + " by " + a.artist, (LastFM.AlbumInfo)a);
             }
             _albums_lock.unlock();
-            
+
             _tracks_lock.lock();
             foreach(Noise.TrackInfo t in lm.dbm.load_tracks()) {
                 _tracks.set(t.name + " by " + t.artist, (LastFM.TrackInfo)t);
@@ -84,98 +84,98 @@
 
             similarMedias.similar_retrieved.connect(similar_retrieved_signal);
         }
-        
+
         /************* Last FM Artist Stuff ************/
         public GLib.List<LastFM.ArtistInfo> artists() {
             var rv = new GLib.List<LastFM.ArtistInfo>();
             foreach(var artist in _artists.values)
                 rv.append(artist);
-            
+
             return rv;
         }
-        
+
         public void save_artist(LastFM.ArtistInfo artist) {
             _artists_lock.lock();
             _artists.set(artist.name.down(), artist);
             _artists_lock.unlock();
         }
-        
+
         public bool artist_info_exists(string artist_key) {
             return _artists.get(artist_key.down()) != null;
         }
-        
+
         public LastFM.ArtistInfo? get_artist(string artist_key) {
             LastFM.ArtistInfo? rv = null;
-            
+
             _artists_lock.lock();
-            if(artist_info_exists(artist_key.down()))    
+            if(artist_info_exists(artist_key.down()))
                 rv = _artists.get(artist_key.down());
             _artists_lock.unlock();
-                
+
             return rv;
         }
-        
+
         /************** LastFM Album stuff **************/
         public GLib.List<LastFM.AlbumInfo> albums() {
             var rv = new GLib.List<LastFM.AlbumInfo>();
             foreach(var album in _albums.values)
                 rv.append(album);
-            
+
             return rv;
         }
-        
+
         public void save_album(LastFM.AlbumInfo album) {
             _albums_lock.lock();
             _albums.set(album.name.down() + " by " + album.artist.down(), album);
             _albums_lock.unlock();
         }
-        
+
         public bool album_info_exists(string album_key) {
             return _albums.get(album_key) != null;
         }
-        
+
         public LastFM.AlbumInfo? get_album(string album_key) {
             LastFM.AlbumInfo? rv = null;
-            
+
             _albums_lock.lock();
-            if(album_info_exists(album_key.down()))    
+            if(album_info_exists(album_key.down()))
                 rv = _albums.get(album_key.down());
             _albums_lock.unlock();
-                
+
             return rv;
         }
-        
+
         /************** Last FM Track Stuff ***************/
         public GLib.List<LastFM.TrackInfo> tracks() {
             var rv = new GLib.List<LastFM.TrackInfo>();
             foreach(var track in _tracks.values)
                 rv.append(track);
-            
+
             return rv;
         }
-        
+
         public void save_track(LastFM.TrackInfo track) {
             _tracks_lock.lock();
             if (track != null && track.name != null && track.artist != null)
             _tracks.set(track.name.down() + " by " + track.artist.down(), track);
             _tracks_lock.unlock();
         }
-        
+
         public bool track_info_exists(string track_key) {
             return _tracks.get(track_key.down()) != null;
         }
-        
+
         public LastFM.TrackInfo? get_track(string track_key) {
             LastFM.TrackInfo? rv = null;
-            
+
             _tracks_lock.lock();
             if(track_info_exists(track_key.down()))
                 rv = _tracks.get(track_key.down());
             _tracks_lock.unlock();
-                
+
             return rv;
         }
-        
+
         /** Last.FM Api functions **/
         public static string fix_for_url(string fix) {
             var fix1 = fix.replace(" ", "%20");
@@ -190,40 +190,40 @@
             var fix0 = fix9.replace("*", "%2A");
             return fix0;
         }
-        
+
         public string generate_md5(string text) {
             return GLib.Checksum.compute_for_string(ChecksumType.MD5, text, text.length);
         }
-        
+
         public string generate_getsession_signature(string token) {
             return generate_md5("api_key" + API + "methodauth.getSessiontoken" + token + SECRET);
         }
-        
+
         public string generate_tracklove_signature(string artist, string track) {
             return generate_md5("api_key" + API + "artist" + artist + "methodtrack.lovesk" + lastfm_settings.session_key + "track" + track + SECRET);
         }
-        
+
         public string generate_trackban_signature(string artist, string track) {
             return generate_md5("api_key" + API + "artist" + artist + "methodtrack.bansk" + lastfm_settings.session_key + "track" + track + SECRET);
         }
-        
+
         public string generate_trackscrobble_signature(string artist, string track, int timestamp) {
             return generate_md5("api_key" + API + "artist" + artist + "methodtrack.scrobblesk" + lastfm_settings.session_key + "timestamp" + timestamp.to_string() + "track" + track + SECRET);
         }
-        
+
         public string generate_trackupdatenowplaying_signature(string artist, string track) {
             return generate_md5("api_key" + API + "artist" + artist + "methodtrack.updateNowPlayingsk" + lastfm_settings.session_key + "track" + track + SECRET);
         }
-        
+
         public string? getToken() {
             var url = "http://ws.audioscrobbler.com/2.0/?method=auth.gettoken&api_key=" + API;
-            
+
             Xml.Doc* doc = Parser.parse_file (url);
             if(doc == null) return null;
-            
+
             Xml.Node* root = doc->get_root_element();
             if(root == null) return null;
-            
+
             for (Xml.Node* iter = root->children; iter != null; iter = iter->next) {
                 if(iter->name == "token") {
                     return iter->get_content();
@@ -231,19 +231,19 @@
             }
             return null;
         }
-        
+
         public string? getSessionKey(string token) {
             var sig = generate_getsession_signature(token);
             var url = "http://ws.audioscrobbler.com/2.0/?method=auth.getSession&api_key=" + API + "&api_sig=" + sig + "&token=" + token;
-            
+
             message ("url: %s\n", url);
-            
+
             Xml.Doc* doc = Parser.parse_file (url);
             if(doc == null) return null;
-            
+
             Xml.Node* root = doc->get_root_element();
             if(root == null) return null;
-            
+
             for (Xml.Node* iter = root->children; iter != null; iter = iter->next) {
                 if(iter->name == "session") {
                     for(Xml.Node* n = iter->children; n != null; n = n->next) {
@@ -255,18 +255,18 @@
             }
             return null;
         }
-        
+
         public bool loveTrack(string title, string artist) {
             if(lastfm_settings.session_key == null || lastfm_settings.session_key == "") {
                 warning ("User tried to ban a track, but is not logged into Last FM\n");
                 return false;
             }
-            
+
             var uri = "http://ws.audioscrobbler.com/2.0/?api_key=" + API + "&api_sig=" + generate_tracklove_signature(artist, title) + "&artist=" + fix_for_url(artist) + "&method=track.love&sk=" + lastfm_settings.session_key + "&track=" + fix_for_url(title);
-            
+
             Soup.SessionSync session = new Soup.SessionSync();
             Soup.Message message = new Soup.Message ("POST", uri);
-            
+
             var headers = new Soup.MessageHeaders(MessageHeadersType.REQUEST);
             headers.append("api_key", API);
             headers.append("api_sig", generate_tracklove_signature(artist, title));
@@ -274,29 +274,29 @@
             headers.append("method", "track.love");
             headers.append("sk", lastfm_settings.session_key);
             headers.append("track", title);
-            
+
             message.request_headers = headers;
-            
+
             /* send the HTTP request */
             session.send_message(message);
-            
+
             if(message.response_body.length == 0)
                 return false;
-            
+
             return true;
         }
-        
+
         public bool banTrack(string title, string artist) {
             if(lastfm_settings.session_key == null || lastfm_settings.session_key == "") {
                 warning ("User tried to ban a track, but is not logged into Last FM\n");
                 return false;
             }
-            
+
             var uri = "http://ws.audioscrobbler.com/2.0/?api_key=" + API + "&api_sig=" + generate_trackban_signature(artist, title) + "&artist=" + fix_for_url(artist) + "&method=track.ban&sk=" + lastfm_settings.session_key + "&track=" + fix_for_url(title);
-            
+
             Soup.SessionSync session = new Soup.SessionSync();
             Soup.Message message = new Soup.Message ("POST", uri);
-            
+
             var headers = new Soup.MessageHeaders(MessageHeadersType.REQUEST);
             headers.append("api_key", API);
             headers.append("api_sig", generate_trackban_signature(artist, title));
@@ -304,31 +304,31 @@
             headers.append("method", "track.ban");
             headers.append("sk", lastfm_settings.session_key);
             headers.append("track", title);
-            
+
             message.request_headers = headers;
-            
+
             /* send the HTTP request */
             session.send_message(message);
-            
+
             if(message.response_body.length == 0)
                 return false;
-            
+
             return true;
         }
-        
+
         /** Fetches the current track's info from last.fm
          */
 
         Mutex fetch_info_guard;
 
         public void fetchCurrentTrackInfo() {
-            Noise.Threads.add (track_thread_function);
+            Idle.add (track_thread_function);
         }
-        
-        void track_thread_function () {
+
+        private bool track_thread_function () {
             var current_media = Noise.App.player.media_info.media;
             if (current_media == null)
-                return;
+                return false;
 
             string album_artist_s = current_media.album_artist;
             string track_s = current_media.title;
@@ -350,17 +350,19 @@
                     Noise.App.player.media_info.track = track;
                 fetch_info_guard.unlock ();
             }
+
+            return false;
         }
-        
+
         public void fetchCurrentAlbumInfo() {
-            Noise.Threads.add (album_thread_function);
+            Idle.add (album_thread_function);
         }
 
-        void album_thread_function () {
+        private bool album_thread_function () {
 
             var current_media = Noise.App.player.media_info.media;
             if (current_media == null)
-                return;
+                return false;
 
             string album_artist_s = current_media.album_artist;
             string album_s = current_media.album;
@@ -373,10 +375,10 @@
                 // This does the fetching to internet. may take a few seconds
                 var album = new LastFM.AlbumInfo.with_info (album_artist_s, album_s);
 
-                if (album != null) 
+                if (album != null)
                     save_album (album);
                 else
-                    return;
+                    return false;
 
                 /* If on same song, update Noise.App.player.media_info.album */
                 fetch_info_guard.lock ();
@@ -391,33 +393,33 @@
                 var coverart_cache = Noise.CoverartCache.instance;
 
                 if (coverart_cache.has_image (current_media))
-                    return;
+                    return false;
 
                 if (album.image_uri != "") {
                     message ("Caching last.fm image from URL: %s", album.image_uri);
 
-                    fetch_info_guard.lock ();
                     var image_file = File.new_for_uri (album.image_uri);
-                    coverart_cache.cache_image_from_file (current_media, image_file);
-                    fetch_info_guard.unlock ();
+                    coverart_cache.cache_image_from_file_async.begin (current_media, image_file);
                 }
 
             }
             else {
                 message ("Not fetching album info or art");
             }
+
+            return false;
         }
-        
+
         /** Fetches artist info for currently playing song's artist
          */
         public void fetchCurrentArtistInfo() {
-            Noise.Threads.add (artist_thread_function);
+            Idle.add (artist_thread_function);
         }
-        
-        void artist_thread_function () {
+
+        private bool artist_thread_function () {
             var current_media = Noise.App.player.media_info.media;
             if (current_media == null)
-                return;
+                return false;
 
             string album_artist_s = current_media.album_artist;
             if (album_artist_s == "")
@@ -442,30 +444,32 @@
 
                 fetch_info_guard.unlock ();
             }
+
+            return false;
         }
-        
+
         /** Update's the user's currently playing track on last.fm
-         * 
+         *
          */
         public void postNowPlaying() {
-            Noise.Threads.add (update_nowplaying_thread_function);
+            Idle.add (update_nowplaying_thread_function);
         }
-        
-        void update_nowplaying_thread_function() {
+
+        private bool update_nowplaying_thread_function() {
             if(lastfm_settings.session_key == null || lastfm_settings.session_key == "") {
                 message ("Last.FM user not logged in\n");
-                return;
+                return false;
             }
             if(!Noise.App.player.media_active)
-                return;
-            
+                return false;
+
             var artist = Noise.App.player.media_info.media.artist;
             var title = Noise.App.player.media_info.media.title;
             var uri = "http://ws.audioscrobbler.com/2.0/?api_key=" + API + "&api_sig=" + generate_trackupdatenowplaying_signature(artist, title) + "&artist=" + fix_for_url(artist) + "&method=track.updateNowPlaying&sk=" + lastfm_settings.session_key + "&track=" + fix_for_url(title);
-            
+
             Soup.SessionSync session = new Soup.SessionSync();
             Soup.Message message = new Soup.Message ("POST", uri);
-            
+
             var headers = new Soup.MessageHeaders(MessageHeadersType.REQUEST);
             headers.append("api_key", API);
             headers.append("api_sig", generate_trackupdatenowplaying_signature(artist, title));
@@ -473,38 +477,40 @@
             headers.append("method", "track.updateNowPlaying");
             headers.append("sk", lastfm_settings.session_key);
             headers.append("track", title);
-            
+
             message.request_headers = headers;
-            
+
             /* send the HTTP request */
             session.send_message(message);
+
+            return false;
         }
-        
+
         /**
          * Scrobbles the currently playing track to last.fm
          */
         public void postScrobbleTrack() {
-            Noise.Threads.add (scrobble_thread_function);
+            Idle.add (scrobble_thread_function);
         }
-        
-        void scrobble_thread_function () {
+
+        private bool scrobble_thread_function () {
             if(lastfm_settings.session_key == null || lastfm_settings.session_key == "") {
                 message ("Last.FM user not logged in\n");
-                return;
+                return false;
             }
             if(!Noise.App.player.media_active)
-                return;
+                return false;
 
             var current_media = Noise.App.player.media_info.media;
-            
+
             var timestamp = (int)time_t();
             var artist = current_media.artist;
             var title = current_media.title;
             var uri = "http://ws.audioscrobbler.com/2.0/?api_key=" + API + "&api_sig=" + generate_trackscrobble_signature(artist, title, timestamp) + "&artist=" + fix_for_url(artist) + "&method=track.scrobble&sk=" + lastfm_settings.session_key + "&timestamp=" + timestamp.to_string() + "&track=" + fix_for_url(title);
-            
+
             Soup.SessionSync session = new Soup.SessionSync();
             Soup.Message message = new Soup.Message ("POST", uri);
-            
+
             var headers = new Soup.MessageHeaders(MessageHeadersType.REQUEST);
             headers.append("api_key", API);
             headers.append("api_sig", generate_trackscrobble_signature(artist, title, timestamp));
@@ -513,17 +519,19 @@
             headers.append("sk", lastfm_settings.session_key);
             headers.append("timestamp", timestamp.to_string());
             headers.append("track", title);
-            
+
             message.request_headers = headers;
-            
+
             /* send the HTTP request */
             session.send_message(message);
+
+            return false;
         }
-        
+
         public void fetchCurrentSimilarSongs() {
             similarMedias.queryForSimilar(Noise.App.player.media_info.media);
         }
-        
+
         void similar_retrieved_signal(LinkedList<int> similarIDs, LinkedList<Noise.Media> similarDont) {
             similar_retrieved(similarIDs, similarDont);
         }

=== modified file 'src/GStreamer/GStreamerTagger.vala'
--- src/GStreamer/GStreamerTagger.vala	2012-08-06 17:12:33 +0000
+++ src/GStreamer/GStreamerTagger.vala	2012-10-06 03:24:21 +0000
@@ -24,146 +24,147 @@
 using Gee;
 
 public class Noise.GStreamerTagger : GLib.Object {
-	LibraryManager lm;
-	static int DISCOVER_SET_SIZE = 50;
-	Gst.Discoverer d;
-	HashMap<string, int> uri_to_id;
-	LinkedList<string> path_queue;
-	
-	public signal void media_imported(Media m);
-	public signal void import_error(string file);
-	public signal void queue_finished();
-	
-	bool cancelled;
-	
-	public GStreamerTagger(LibraryManager lm) {
-		this.lm = lm;
+
+        LibraryManager lm;
+        static int DISCOVER_SET_SIZE = 50;
+        Gst.Discoverer d;
+        HashMap<string, int> uri_to_id;
+        LinkedList<string> path_queue;
+
+        public signal void media_imported(Media m);
+        public signal void import_error(string file);
+        public signal void queue_finished();
+
+        bool cancelled;
+
+        public GStreamerTagger(LibraryManager lm) {
+                this.lm = lm;
 
         d = create_discoverer ();
 
-		
-		uri_to_id = new HashMap<string, int>();
-		path_queue = new LinkedList<string>();
-	}
+
+                uri_to_id = new HashMap<string, int>();
+                path_queue = new LinkedList<string>();
+        }
 
     private Gst.Discoverer? create_discoverer () {
         Gst.Discoverer? discoverer = null;
 
-		try {
-			discoverer = new Gst.Discoverer ((ClockTime)(30*Gst.SECOND));
-		}
-		catch (Error err) {
-			critical ("Metadata reader could not create discoverer object: %s\n", err.message);
-		}
+                try {
+                        discoverer = new Gst.Discoverer ((ClockTime)(30*Gst.SECOND));
+                }
+                catch (Error err) {
+                        critical ("Metadata reader could not create discoverer object: %s\n", err.message);
+                }
 
-		discoverer.discovered.connect (import_media);
-		discoverer.finished.connect (finished);
+                discoverer.discovered.connect (import_media);
+                discoverer.finished.connect (finished);
 
         return discoverer;
     }
 
-	void finished() {
-		if(!cancelled && path_queue.size > 0) {
-			d = create_discoverer ();
-			
-			d.start();
-			for(int i = 0; i < DISCOVER_SET_SIZE && i < path_queue.size; ++i) {
-				d.discover_uri_async("file://" + path_queue.get(i));
-			}
-		}
-		else {
-			debug("queue finished\n");
-			queue_finished();
-		}
-	}
-
-	public void cancel_operations() {
-		cancelled = true;
-	}
-
-	public void discoverer_import_media (LinkedList<string> files) {
-		int size = 0;
-		cancelled = false;
-		path_queue.clear();
-		
-		foreach(string s in files) {
-			path_queue.add(s);
-			
-			d.start();
-			if(size < DISCOVER_SET_SIZE) {
-				++size;
-				d.discover_uri_async("file://" + s);
-			}
-		}
-	}
-	
-	void import_media(DiscovererInfo info, Error err) {
-		path_queue.remove(info.get_uri().replace("file://",""));
+        void finished() {
+                if(!cancelled && path_queue.size > 0) {
+                        d = create_discoverer ();
+
+                        d.start();
+                        for(int i = 0; i < DISCOVER_SET_SIZE && i < path_queue.size; ++i) {
+                                d.discover_uri_async("file://" + path_queue.get(i));
+                        }
+                }
+                else {
+                        debug("queue finished\n");
+                        queue_finished();
+                }
+        }
+
+        public void cancel_operations() {
+                cancelled = true;
+        }
+
+        public void discoverer_import_media (LinkedList<string> files) {
+                int size = 0;
+                cancelled = false;
+                path_queue.clear();
+
+                foreach(string s in files) {
+                        path_queue.add(s);
+
+                        d.start();
+                        if(size < DISCOVER_SET_SIZE) {
+                                ++size;
+                                d.discover_uri_async("file://" + s);
+                        }
+                }
+        }
+
+        private async void import_media(DiscovererInfo info, Error err) {
+                path_queue.remove(info.get_uri().replace("file://",""));
 
         Media? s = null;
 
-		if(info != null && info.get_tags() != null) {
-			s = new Media(info.get_uri());
-			
-			string title = "";
-			string artist, composer, album_artist, album, grouping, genre, comment, lyrics;
-			uint track, track_count, album_number, album_count, bitrate, rating;
-			double bpm;
-			GLib.Date? date = GLib.Date();
-			
-			// get title, artist, album artist, album, genre, comment, lyrics strings
-			if(info.get_tags().get_string(TAG_TITLE, out title))
-				s.title = title;
-			if(info.get_tags().get_string(TAG_ARTIST, out artist))
-				s.artist = artist;
-			if(info.get_tags().get_string(TAG_COMPOSER, out composer))
-				s.composer = composer;
-			
-			if(info.get_tags().get_string(TAG_ALBUM_ARTIST, out album_artist))
-				s.album_artist = album_artist;
-			else
-				s.album_artist = s.artist;
-			
-			if(info.get_tags().get_string(TAG_ALBUM, out album))
-				s.album = album;
-			if(info.get_tags().get_string(TAG_GROUPING, out grouping))
-				s.grouping = grouping;
-			if(info.get_tags().get_string(TAG_GENRE, out genre))
-				s.genre = genre;
-			if(info.get_tags().get_string(TAG_COMMENT, out comment))
-				s.comment = comment;
-			if(info.get_tags().get_string(TAG_LYRICS, out lyrics))
-				s.lyrics = lyrics;
-			
-			// get the year
-			if(info.get_tags().get_date(TAG_DATE, out date)) {
-				if(date != null)
-					s.year = (int)date.get_year();
-			}
-			// get track/album number/count, bitrating, rating, bpm
-			if(info.get_tags().get_uint(TAG_TRACK_NUMBER, out track))
-				s.track = (int)track;
-			if(info.get_tags().get_uint(TAG_TRACK_COUNT, out track_count))
-				s.track_count = track_count;
-				
-			if(info.get_tags().get_uint(TAG_ALBUM_VOLUME_NUMBER, out album_number))
-				s.album_number = album_number;
-			if(info.get_tags().get_uint(TAG_ALBUM_VOLUME_COUNT, out album_count))
-				s.album_count = album_count;
-			
-			if(info.get_tags().get_uint(TAG_BITRATE, out bitrate))
-				s.bitrate = (int)(bitrate/1000);
-			if(info.get_tags().get_uint(TAG_USER_RATING, out rating))
-				s.rating = (int)((rating > 0 && rating <= 5) ? rating : 0);
-			if(info.get_tags().get_double(TAG_BEATS_PER_MINUTE, out bpm))
-				s.bpm = (int)bpm;
-
-
-			// get length
+                if(info != null && info.get_tags() != null) {
+                        s = new Media(info.get_uri());
+
+                        string title = "";
+                        string artist, composer, album_artist, album, grouping, genre, comment, lyrics;
+                        uint track, track_count, album_number, album_count, bitrate, rating;
+                        double bpm;
+                        GLib.Date? date = GLib.Date();
+
+                        // get title, artist, album artist, album, genre, comment, lyrics strings
+                        if(info.get_tags().get_string(TAG_TITLE, out title))
+                                s.title = title;
+                        if(info.get_tags().get_string(TAG_ARTIST, out artist))
+                                s.artist = artist;
+                        if(info.get_tags().get_string(TAG_COMPOSER, out composer))
+                                s.composer = composer;
+
+                        if(info.get_tags().get_string(TAG_ALBUM_ARTIST, out album_artist))
+                                s.album_artist = album_artist;
+                        else
+                                s.album_artist = s.artist;
+
+                        if(info.get_tags().get_string(TAG_ALBUM, out album))
+                                s.album = album;
+                        if(info.get_tags().get_string(TAG_GROUPING, out grouping))
+                                s.grouping = grouping;
+                        if(info.get_tags().get_string(TAG_GENRE, out genre))
+                                s.genre = genre;
+                        if(info.get_tags().get_string(TAG_COMMENT, out comment))
+                                s.comment = comment;
+                        if(info.get_tags().get_string(TAG_LYRICS, out lyrics))
+                                s.lyrics = lyrics;
+
+                        // get the year
+                        if(info.get_tags().get_date(TAG_DATE, out date)) {
+                                if(date != null)
+                                        s.year = (int)date.get_year();
+                        }
+                        // get track/album number/count, bitrating, rating, bpm
+                        if(info.get_tags().get_uint(TAG_TRACK_NUMBER, out track))
+                                s.track = (int)track;
+                        if(info.get_tags().get_uint(TAG_TRACK_COUNT, out track_count))
+                                s.track_count = track_count;
+
+                        if(info.get_tags().get_uint(TAG_ALBUM_VOLUME_NUMBER, out album_number))
+                                s.album_number = album_number;
+                        if(info.get_tags().get_uint(TAG_ALBUM_VOLUME_COUNT, out album_count))
+                                s.album_count = album_count;
+
+                        if(info.get_tags().get_uint(TAG_BITRATE, out bitrate))
+                                s.bitrate = (int)(bitrate/1000);
+                        if(info.get_tags().get_uint(TAG_USER_RATING, out rating))
+                                s.rating = (int)((rating > 0 && rating <= 5) ? rating : 0);
+                        if(info.get_tags().get_double(TAG_BEATS_PER_MINUTE, out bpm))
+                                s.bpm = (int)bpm;
+
+
+                        // get length
             uint64 duration = info.get_duration ();
 
             if (duration == 0)
-    			info.get_tags ().get_uint64 (TAG_DURATION, out duration);
+                        info.get_tags ().get_uint64 (TAG_DURATION, out duration);
 
             // we convert from nanoseconds (10E-9) to miliseconds (10E-3);
             s.length = (uint)((duration * Numeric.MILI_INV) / Numeric.NANO_INV);
@@ -188,63 +189,63 @@
             }
 
             // Get cover art
-			import_art (s, info);
-		}
-		else {
-			s = taglib_import_media(info.get_uri());
+                        import_art_async.begin (s, info);
+                }
+                else {
+                        s = taglib_import_media(info.get_uri());
 
-	        if (s == null) {
-		        import_error (info.get_uri().replace("file://", ""));
-		        return;
+                if (s == null) {
+                        import_error (info.get_uri().replace("file://", ""));
+                        return;
             }
-		}
-
-		// get the size
-		s.file_size = FileUtils.get_size (s.file);
-		s.date_added = (int)time_t();
-
-   		media_imported(s);
-	}
-	
-	public Media? taglib_import_media(string uri) {
-		Media s = new Media(uri);
-		TagLib.File tag_file;
-		
-		tag_file = new TagLib.File(uri.replace("file://",""));
-		
-		if(tag_file != null && tag_file.tag != null && tag_file.audioproperties != null) {
-			try {
-				s.title = tag_file.tag.title;
-				s.artist = tag_file.tag.artist;
-				s.album = tag_file.tag.album;
-				s.genre = tag_file.tag.genre;
-				s.comment = tag_file.tag.comment;
-				s.year = (int)tag_file.tag.year;
-				s.track = (int)tag_file.tag.track;
-				s.bitrate = tag_file.audioproperties.bitrate;
-
-				s.length = (uint)(tag_file.audioproperties.length * Numeric.MILI_INV);
-				s.samplerate = tag_file.audioproperties.samplerate;
-			}
-			finally {
-				if(s.title == null || s.title == "") {
-					string[] paths = uri.split("/", 0);
-					s.title = paths[paths.length - 1];
-				}
-				if(s.artist == null || s.artist == "") s.artist = Media.UNKNOWN_ARTIST;
-
-				s.album_artist = s.artist;
-				s.album_number = 1;
-			}
-		}
-		else {
-			return null;
-		}
-		
-		return s;
-	}
-	
-	void import_art (Media m, DiscovererInfo info) {
+                }
+
+                // get the size
+                s.file_size = yield FileUtils.get_size_async (s.file);
+                s.date_added = (int)time_t();
+
+                media_imported(s);
+        }
+
+        public Media? taglib_import_media(string uri) {
+                Media s = new Media(uri);
+                TagLib.File tag_file;
+
+                tag_file = new TagLib.File(uri.replace("file://",""));
+
+                if(tag_file != null && tag_file.tag != null && tag_file.audioproperties != null) {
+                        try {
+                                s.title = tag_file.tag.title;
+                                s.artist = tag_file.tag.artist;
+                                s.album = tag_file.tag.album;
+                                s.genre = tag_file.tag.genre;
+                                s.comment = tag_file.tag.comment;
+                                s.year = (int)tag_file.tag.year;
+                                s.track = (int)tag_file.tag.track;
+                                s.bitrate = tag_file.audioproperties.bitrate;
+
+                                s.length = (uint)(tag_file.audioproperties.length * Numeric.MILI_INV);
+                                s.samplerate = tag_file.audioproperties.samplerate;
+                        }
+                        finally {
+                                if(s.title == null || s.title == "") {
+                                        string[] paths = uri.split("/", 0);
+                                        s.title = paths[paths.length - 1];
+                                }
+                                if(s.artist == null || s.artist == "") s.artist = Media.UNKNOWN_ARTIST;
+
+                                s.album_artist = s.artist;
+                                s.album_number = 1;
+                        }
+                }
+                else {
+                        return null;
+                }
+
+                return s;
+        }
+
+        private async void import_art_async (Media m, DiscovererInfo info) {
         var cache = CoverartCache.instance;
 
         if (cache.has_image (m))
@@ -253,10 +254,10 @@
         var pix = get_image (info.get_tags ());
 
         if (pix != null)
-            cache.cache_image (m, pix);
+            yield cache.cache_image_async (m, pix);
         else
             warning ("import_art: null pixbuf");
-	}
+        }
 
     private static Gdk.Pixbuf? get_image (Gst.TagList tag) {
         Gst.Buffer? buffer = null;
@@ -274,14 +275,14 @@
                 continue;
 
             int image_type;
-			structure.get_enum ("image-type", typeof (Gst.TagImageType), out image_type);
+                        structure.get_enum ("image-type", typeof (Gst.TagImageType), out image_type);
 
-			if (image_type == Gst.TagImageType.FRONT_COVER) {
-				buffer = loop_buffer;
-				break;
-			} else if (image_type == Gst.TagImageType.UNDEFINED || buffer == null) {
+                        if (image_type == Gst.TagImageType.FRONT_COVER) {
+                                buffer = loop_buffer;
+                                break;
+                        } else if (image_type == Gst.TagImageType.UNDEFINED || buffer == null) {
                 buffer = loop_buffer;
-			}
+                        }
         }
 
         if (buffer == null) {
@@ -306,100 +307,100 @@
 
         return pix;
     }
-	
-	public bool save_media(Media s) {
-		return false;
-	
-		/*Gst.Pipeline pipe = new Pipeline("pipe");
-		Element src = Element.make_from_uri(URIType.SRC, "file://" + s.file, null);
-		Element decoder = ElementFactory.make("decodebin", "decoder");
-		
-		GLib.Signal.connect(decoder, "new-decoded-pad", (GLib.Callback)newDecodedPad, this);
-		
-		if(!((Gst.Bin)pipe).add_many(src, decoder)) {
-			message ("Could not add src and decoder to pipeline to save metadata\n");
-			return false;
-		}
-		
-		if(!src.link_many(decoder)) {
-			message ("Could not link src to decoder to save metadata\n");
-			return false;
-		}
-		
-		
-		Gst.Element queue = ElementFactory.make("queue", "queue");
-		Gst.Element queue2 = ElementFactory.make("queue", "queue2");
-		
-		if(queue == null || queue2 == null) {
-			message ("could not add create queues to save metadata\n");
-			return false;
-		}
-		
-		if(!((Gst.Bin)pipe).add_many(queue, queue2)) {
-			warning ("Could not add queue's to save metadata\n");
-			return false;
-		}
-		
-		queue.set("max-size-time", 120 * Gst.SECOND);
-		
-		
-		
-		
-		//Element encoder = new_element_from_uri(URIType.SINK, "file://" + s.file, null);
-		
-		Gst.TagList tags;
-		bool rv = true;
-		//long day;
-		
-		tags = new TagList();
-		tags.add(TagMergeMode.REPLACE,  TAG_TITLE, s.title,
-										TAG_ARTIST, s.artist,
-										TAG_COMPOSER, s.composer,
-										TAG_ALBUM_ARTIST, s.album_artist,
-										TAG_ALBUM, s.album,
-										TAG_GROUPING, s.grouping,
-										TAG_GENRE, s.genre,
-										TAG_COMMENT, s.comment,
-										TAG_LYRICS, s.lyrics,
-										TAG_TRACK_NUMBER, s.track,
-										TAG_TRACK_COUNT, s.track_count,
-										TAG_ALBUM_VOLUME_NUMBER, s.album_number,
-										TAG_ALBUM_VOLUME_COUNT, s.album_count,
-										TAG_USER_RATING, s.rating);
-		
-		/* fetch date, set new year to s.year, set date */
-		
-		// now find a tag setter interface and use it
-		/*Gst.Iterator iter;
-		bool done;
-
-		iter = ((Gst.Bin)pipeline).iterate_all_by_interface(typeof(Gst.TagSetter));
-		done = false;
-		while (!done) {
-			  Gst.TagSetter tagger = null;
-
-			  switch (iter.next(out tagger) {
-			  case GST_ITERATOR_OK:
-					tagger.merge_tags (tags, GST_TAG_MERGE_REPLACE_ALL);
-					break;
-			  case GST_ITERATOR_RESYNC:
-					iter.resync();
-					break;
-			  case GST_ITERATOR_ERROR:
-					warning("Could not update metadata on media\n");
-					rv = false;
-					done = true;
-					break;
-			  case GST_ITERATOR_DONE:
-					done = true;
-					break;
-			  }
-		}
-		
-		return rv;	*/
-	}
-
-	public bool save_embeddeart_d(Gdk.Pixbuf pix) {
-		return false;
-	}
+
+        public bool save_media(Media s) {
+                return false;
+
+                /*Gst.Pipeline pipe = new Pipeline("pipe");
+                Element src = Element.make_from_uri(URIType.SRC, "file://" + s.file, null);
+                Element decoder = ElementFactory.make("decodebin", "decoder");
+
+                GLib.Signal.connect(decoder, "new-decoded-pad", (GLib.Callback)newDecodedPad, this);
+
+                if(!((Gst.Bin)pipe).add_many(src, decoder)) {
+                        message ("Could not add src and decoder to pipeline to save metadata\n");
+                        return false;
+                }
+
+                if(!src.link_many(decoder)) {
+                        message ("Could not link src to decoder to save metadata\n");
+                        return false;
+                }
+
+
+                Gst.Element queue = ElementFactory.make("queue", "queue");
+                Gst.Element queue2 = ElementFactory.make("queue", "queue2");
+
+                if(queue == null || queue2 == null) {
+                        message ("could not add create queues to save metadata\n");
+                        return false;
+                }
+
+                if(!((Gst.Bin)pipe).add_many(queue, queue2)) {
+                        warning ("Could not add queue's to save metadata\n");
+                        return false;
+                }
+
+                queue.set("max-size-time", 120 * Gst.SECOND);
+
+
+
+
+                //Element encoder = new_element_from_uri(URIType.SINK, "file://" + s.file, null);
+
+                Gst.TagList tags;
+                bool rv = true;
+                //long day;
+
+                tags = new TagList();
+                tags.add(TagMergeMode.REPLACE,  TAG_TITLE, s.title,
+                                                                                TAG_ARTIST, s.artist,
+                                                                                TAG_COMPOSER, s.composer,
+                                                                                TAG_ALBUM_ARTIST, s.album_artist,
+                                                                                TAG_ALBUM, s.album,
+                                                                                TAG_GROUPING, s.grouping,
+                                                                                TAG_GENRE, s.genre,
+                                                                                TAG_COMMENT, s.comment,
+                                                                                TAG_LYRICS, s.lyrics,
+                                                                                TAG_TRACK_NUMBER, s.track,
+                                                                                TAG_TRACK_COUNT, s.track_count,
+                                                                                TAG_ALBUM_VOLUME_NUMBER, s.album_number,
+                                                                                TAG_ALBUM_VOLUME_COUNT, s.album_count,
+                                                                                TAG_USER_RATING, s.rating);
+
+                /* fetch date, set new year to s.year, set date */
+
+                // now find a tag setter interface and use it
+                /*Gst.Iterator iter;
+                bool done;
+
+                iter = ((Gst.Bin)pipeline).iterate_all_by_interface(typeof(Gst.TagSetter));
+                done = false;
+                while (!done) {
+                          Gst.TagSetter tagger = null;
+
+                          switch (iter.next(out tagger) {
+                          case GST_ITERATOR_OK:
+                                        tagger.merge_tags (tags, GST_TAG_MERGE_REPLACE_ALL);
+                                        break;
+                          case GST_ITERATOR_RESYNC:
+                                        iter.resync();
+                                        break;
+                          case GST_ITERATOR_ERROR:
+                                        warning("Could not update metadata on media\n");
+                                        rv = false;
+                                        done = true;
+                                        break;
+                          case GST_ITERATOR_DONE:
+                                        done = true;
+                                        break;
+                          }
+                }
+
+                return rv;      */
+        }
+
+        public bool save_embeddeart_d(Gdk.Pixbuf pix) {
+                return false;
+        }
 }

=== modified file 'src/LibraryWindow.vala'
--- src/LibraryWindow.vala	2012-09-25 20:11:04 +0000
+++ src/LibraryWindow.vala	2012-10-06 03:24:21 +0000
@@ -362,7 +362,7 @@
 #endif
     }
 
-    public void show_notification_from_media (Media media) {
+    public async void show_notification_from_media_async (Media media) {
         if (media == null)
             return;
 
@@ -372,8 +372,8 @@
         Gdk.Pixbuf? pixbuf = null;
 
         try {
-            string path = CoverartCache.instance.get_cached_image_path_for_media (media);
-            pixbuf = new Gdk.Pixbuf.from_file_at_size (path, 64, 64);
+            var file = File.new_for_path (CoverartCache.instance.get_cached_image_path_for_media (media));
+            pixbuf = yield PixbufUtils.get_pixbuf_from_file_at_scale_async (file, 64, 64, false);
         } catch (Error err) {
             // Media often doesn't have an associated album art,
             // so we shouldn't treat this as an unexpected error.
@@ -383,9 +383,9 @@
         show_notification (primary_text, secondary_text, pixbuf);
     }
 
-    private void notify_current_media () {
+    private async void notify_current_media_async () {
         if (App.player.media_info != null && App.player.media_info.media != null)
-            show_notification_from_media (App.player.media_info.media);
+            yield show_notification_from_media_async (App.player.media_info.media);
     }
 
     /**
@@ -539,11 +539,17 @@
     }
 
 
+    private bool update_sensitivities_pending = false;
 
     /**
      * This is handled more carefully inside each ViewWrapper object.
      */
     public async void update_sensitivities () {
+        if (update_sensitivities_pending)
+            return;
+
+        update_sensitivities_pending = true;
+
         Idle.add_full (Priority.HIGH_IDLE, update_sensitivities.callback);
         yield;
 
@@ -590,7 +596,10 @@
 
         if(!App.player.media_active || have_media && !App.player.playing) {
             playButton.set_stock_id(Gtk.Stock.MEDIA_PLAY);
+
         }
+
+        update_sensitivities_pending = false;
     }
 
     public virtual void progressNotification(string? message, double progress) {
@@ -742,7 +751,7 @@
             App.player.player.play();
 
             if (!inhibit_notifications)
-                notify_current_media ();
+                notify_current_media_async.begin ();
         }
         else {
             if(App.player.playing) {
@@ -788,7 +797,7 @@
         }
 
         if (!inhibit_notifications)
-            notify_current_media ();
+            notify_current_media_async.begin ();
     }
 
     public virtual void play_previous_media (bool inhibit_notifications = false) {
@@ -804,7 +813,7 @@
                 return;
             }
             else if (play && !inhibit_notifications) {
-                notify_current_media ();
+                notify_current_media_async.begin ();
             }
         }
         else

=== modified file 'src/Objects/CoverartCache.vala'
--- src/Objects/CoverartCache.vala	2012-10-04 22:32:58 +0000
+++ src/Objects/CoverartCache.vala	2012-10-06 03:24:21 +0000
@@ -44,7 +44,6 @@
 
     private Gdk.Pixbuf default_image;
 
-
     public CoverartCache () {
         assert (_instance == null);
 
@@ -54,13 +53,13 @@
         default_image = filter_func (default_pix);
     }
 
-
-    // add a shadow to every image
+    /**
+     * Adds a shadow to every image.
+     */
     protected override Gdk.Pixbuf? filter_func (Gdk.Pixbuf pix) {
         return PixbufUtils.get_pixbuf_shadow (pix, Icons.ALBUM_VIEW_IMAGE_SIZE);
     }
 
-
     protected override string get_key (Media m) {
         string album_name = m.album;
         string artist_name = m.album_artist;
@@ -71,137 +70,126 @@
         return @"$artist_name-$album_name";
     }
 
-
     public Gdk.Pixbuf get_cover (Media m) {
-        var image = get_image (m, false);
-        return image ?? default_image;
+        return get_image (m) ?? default_image;
     }
 
-
     public async void fetch_all_cover_art_async (Gee.Collection<Media> media) {
         yield fetch_folder_images_async (media);
         yield load_for_media_async (media);
     }
 
-
+    /**
+     * Retrieves images from the cache for the specified media.
+     */
     public async void load_for_media_async (Gee.Collection<Media> media) {
-        SourceFunc callback = load_for_media_async.callback;
-
-        Threads.add ( () => {
-            load_for_media (media);
-            Idle.add ((owned)callback);
-        });
-
-        yield;
-    }
-
-
-    public void load_for_media (Gee.Collection<Media> media) {
-        debug ("READING CACHED COVERART");
-
+        // get_key() can yield a similar key for different media files, so we keep
+        // track of all the keys we've explored in order to lookup images only once
+        // for every equivalent media.
         var used_keys_set = new Gee.HashSet<string> ();
 
         foreach (var m in media) {
             string key = get_key (m);
-
             if (!used_keys_set.contains (key) && !has_image (m)) {
-                debug ("Getting [%s]", key);
-
-                // Pass true to lookup_file in order to fetch the images for the first time
-                get_image (m, true);
-
+                yield get_image_async (m, true);
                 used_keys_set.add (key);
             }
         }
 
-        debug ("FINISHED LOADING CACHED COVERART");
-
         queue_notify ();
     }
 
-
+    /**
+     * Looks up for image types in the media's directory.
+     */
     public async void fetch_folder_images_async (Gee.Collection<Media> media) {
-        SourceFunc callback = fetch_folder_images_async.callback;
-
-        Threads.add ( () => {
-            fetch_folder_images (media);
-
-            Idle.add ((owned) callback);
-        });
-
-        yield;
-    }
-
-
-    /**
-     * Looks up for image types in the media's directory. We look for image files
-     * that follow certain name patterns, like "album.png", "folder.jpg", etc.
-     */
-    public void fetch_folder_images (Gee.Collection<Media> media) {
+        // get_key() can yield a similar key for different media files, so we keep
+        // track of all the keys we've explored in order to lookup images only once
+        // for every equivalent media.
+        var used_keys_set = new Gee.HashSet<string> ();
+
         foreach (var m in media) {
-            if (!has_image (m)) {
-                var art_file = lookup_folder_image_file (m);
+            string key = get_key (m);
+            if (!used_keys_set.contains (key) && !has_image (m)) {
+                var art_file = yield lookup_folder_image_file_async (m);
                 if (art_file != null)
-                    cache_image_from_file (m, art_file);
+                    yield cache_image_from_file_async (m, art_file);
+
+                used_keys_set.add (key);
             }
         }
-
-        queue_notify ();
     }
 
 
-    // Awesome method taken from BeatBox's FileOperator.vala (adapted to use Noise's internal API)
-    private static File? lookup_folder_image_file (Media m) {
-        File? rv = null, media_file = m.file;
+    /**
+     * Looks up a valid album image in a media's directory.
+     *
+     * It tries to find image files that follow certain name patterns, like "album.png",
+     * "folder.jpg", the album name, etc. If no image matching the pattern is found, null
+     * is returned.
+     */
+    private static async File? lookup_folder_image_file_async (Media m) {
+        File? media_file = m.file;
+        return_val_if_fail (media_file != null, null);
 
-        if (!media_file.query_exists ())
-            return rv;
+        // Check file existence
+        return_val_if_fail (yield FileUtils.query_exists_async (media_file), null);
 
         var album_folder = media_file.get_parent ();
-
-        if (album_folder == null)
-            return rv;
+        return_val_if_fail (album_folder != null, null);
 
         // Don't consider generic image names if the album folder doesn't contain the name of
         // the media's album. This is probably the simpler way to prevent considering images
         // from folders that contain multiple unrelated tracks.
         bool generic_folder = !album_folder.get_path ().contains (m.album);
 
-        string[] image_types = { "jpg", "jpeg", "png" };
+        string[] image_types = { "jpg", "jpeg", "png", "tiff" };
         Gee.Collection<File> image_files;
-        FileUtils.enumerate_files (album_folder, image_types, false, out image_files);
+        yield FileUtils.enumerate_files_async (album_folder, image_types, false, out image_files);
 
+        File? image_file = null;
+        bool good_image_found = false;
         // Choose an image based on priorities.
+
         foreach (var file in image_files) {
-            string file_path = file.get_path ().down ();
+            // We don't want to be fooled by strange characters or whitespace
+            string file_path = String.canonicalize_for_search (file.get_path ().down ());
+            string album_name = String.canonicalize_for_search ((m.album ?? "").down ());
 
             if (generic_folder) {
-                if (m.album in file_path) {
-                    rv = file;
+                if (!String.is_white_space (album_name) && album_name in file_path) {
+                    image_file = file;
                     break;
                 }
 
                 continue;
             }
 
-
             if ("folder" in file_path) {
-                rv = file;
+                image_file = file;
+                good_image_found = true;
                 break;
             }
 
             if ("cover" in file_path) {
-                rv = file;
-            } else if (rv != null) {
-                if (!("cover" in rv.get_path ()) && "album" in file_path)
-                    rv = file;
-                else if (!("album" in rv.get_path ()) && "front" in file_path)
-                    rv = file;
-                else if (!("front" in rv.get_path ()) && m.album in file_path)
-                    rv = file;
+                good_image_found = true;
+                image_file = file;
+                continue;
+            }
+
+            // Let's use whatever we found
+            if (image_file == null)
+                image_file = file;
+
+            if (!("cover" in image_file.get_path ()) && "album" in file_path) {
+                good_image_found = true;
+                image_file = file;
+            } else if (!("album" in image_file.get_path ()) && "front" in file_path) {
+                good_image_found = true;
+                image_file = file;
             }
         }
 
-        return rv;
+        return good_image_found ? image_file : null;
     }
 }

=== modified file 'src/Objects/MediaArtCache.vala'
--- src/Objects/MediaArtCache.vala	2012-09-24 19:58:02 +0000
+++ src/Objects/MediaArtCache.vala	2012-10-06 03:24:21 +0000
@@ -103,8 +103,8 @@
      * (e.g. due to metadata changes, etc.), since the old pixbuf and cached image
      * are overwritten.
      */
-    public void cache_image (Media m, Gdk.Pixbuf image) {
-        pixbuf_cache.cache_image (get_key (m), image);
+    public async void cache_image_async (Media m, Gdk.Pixbuf image) {
+        yield pixbuf_cache.cache_image_async (get_key (m), image);
         queue_notify ();
     }
 
@@ -112,8 +112,8 @@
      * This method does the same as cache_image(), with the only difference that it
      * first fetches the image from the given file.
      */
-    public void cache_image_from_file (Media m, File image_file, Cancellable? c = null) {
-        pixbuf_cache.cache_image_from_file (get_key (m), image_file, c);
+    public async void cache_image_from_file_async (Media m, File image_file, Cancellable? c = null) {
+        yield pixbuf_cache.cache_image_from_file_async (get_key (m), image_file, c);
         queue_notify ();
     }
 
@@ -131,8 +131,16 @@
      * @return null if the media's corresponding image was not found; otherwise
      *         a valid {@link Gdk.Pixbuf}
      */
-    protected Gdk.Pixbuf? get_image (Media m, bool lookup_file) {
-        return pixbuf_cache.get_image (get_key (m), lookup_file);
+    protected Gdk.Pixbuf? get_image (Media m) {
+        return pixbuf_cache.get_image (get_key (m));
+    }
+
+    /**
+     * @return null if the media's corresponding image was not found; otherwise
+     *         a valid {@link Gdk.Pixbuf}
+     */
+    protected async Gdk.Pixbuf? get_image_async (Media m, bool lookup_file) {
+        return yield pixbuf_cache.get_image_async (get_key (m), lookup_file);
     }
 
     protected void queue_notify () {

=== modified file 'src/Utils/PixbufCache.vala'
--- src/Utils/PixbufCache.vala	2012-10-04 22:32:58 +0000
+++ src/Utils/PixbufCache.vala	2012-10-06 03:24:21 +0000
@@ -50,12 +50,13 @@
  * to be generic). It should be easy to re-use it on another application.
  */
 public class Noise.PixbufCache {
+    private const string DEFAULT_FORMAT_NAME = "jpeg";
 
     public Gee.Map<string, Gdk.Pixbuf> images {
         owned get { return image_map.read_only_view; }
     }
 
-    public string image_format { get; private set; default = "jpeg"; }
+    public Gdk.PixbufFormat image_format { get; private set; }
 
     private File image_dir;
     private Gee.HashMap<string, Gdk.Pixbuf> image_map;
@@ -68,11 +69,20 @@
      * @param image_format a string specifying the image format, or null to use the default
      * format (JPEG). Valid image formats are those supported by {@link Gdk.Pixbuf.save}.
      */
-    public PixbufCache (File image_dir, string? image_format = null) {
-        image_map = new Gee.HashMap<string, Gdk.Pixbuf> ();
-
-        if (image_format != null)
+    public PixbufCache (File image_dir, Gdk.PixbufFormat? image_format = null) {
+        if (image_format == null) {
+            foreach (var format in Gdk.Pixbuf.get_formats ()) {
+                if (format.get_name () == DEFAULT_FORMAT_NAME) {
+                    this.image_format = format;
+                    break;
+                }
+            }
+        } else {
             this.image_format = image_format;
+        }
+
+        // We need to be able to write images to disk for permanent storage
+        assert (this.image_format != null && this.image_format.is_writable ());
 
         this.image_dir = image_dir;
 
@@ -82,6 +92,8 @@
             if (!(err is IOError.EXISTS))
                 warning ("Could not create image cache directory: %s", err.message);
         }
+
+        image_map = new Gee.HashMap<string, Gdk.Pixbuf> ();
     }
 
     /**
@@ -113,7 +125,7 @@
      * recommended to use {@link Noise.PixbufCache.has_image} to check for that.
      */
     public string get_cached_image_path (string key) {
-        string filename = Checksum.compute_for_string (ChecksumType.MD5, key + image_format);
+        string filename = Checksum.compute_for_string (ChecksumType.MD5, key + image_format.get_name ());
         return image_dir.get_child (filename).get_path ();
     }
 
@@ -141,19 +153,30 @@
      * This method can also be used to update image buffers when they have changed,
      * since the old image is overwritten (in both primary memory and disk.)
      */
-    public void cache_image (string key, Gdk.Pixbuf image) {
-        cache_image_internal (key, image, true);
+    public async void cache_image_async (string key, Gdk.Pixbuf image) {
+        yield cache_image_internal_async (key, image, true);
     }
 
     /**
      * This method does the same as {@link Noise.PixbufCache.cache_image}, with the only
      * difference that it first fetches the image from the given file.
      */
-    public void cache_image_from_file (string key, File image_file, Cancellable? c = null) {
-        var image = load_image_from_file (image_file, c);
+    public async void cache_image_from_file_async (string key, File image_file, Cancellable? c = null) {
+        var image = yield load_image_from_file_async (image_file, c);
         if (image != null)
-            cache_image (key, image);
-    }
+            yield cache_image_async (key, image);
+    }
+
+
+    /**
+     * Retrieves the image for the given key from the cache.
+     *
+     * @return A valid {@link Gdk.Pixbuf}, or null if the image is not found.
+     */
+    public Gdk.Pixbuf? get_image (string key) {
+        return image_map.get (key);
+    }
+
 
     /**
      * Retrieves the image for the given key from the cache. If lookup_file
@@ -165,12 +188,12 @@
      * @return null if the key's corresponding image was not found; Otherwise
      *         a valid {@link Gdk.Pixbuf}
      */
-    public Gdk.Pixbuf? get_image (string key, bool lookup_file = true) {
-        if (lookup_file && !image_map.has_key (key)) {
+    public async Gdk.Pixbuf? get_image_async (string key, bool lookup_file = true) {
+        if (lookup_file && !has_image (key)) {
             var image_file = File.new_for_path (get_cached_image_path (key));
-            var image = load_image_from_file (image_file, null);
+            var image = yield load_image_from_file_async (image_file, null);
             if (image != null)
-                cache_image_internal (key, image, false);
+                yield cache_image_internal_async (key, image, false);
         }
 
         return image_map.get (key);
@@ -179,7 +202,7 @@
     /**
      * Adds an image to the hash map and also writes the image to disk if save_to_disk is true.
      */
-    private void cache_image_internal (string key, Gdk.Pixbuf image, bool save_to_disk) {
+    private async void cache_image_internal_async (string key, Gdk.Pixbuf image, bool save_to_disk) {
         Gdk.Pixbuf? modified_image = (filter_func != null) ? filter_func (key, image) : image;
 
         if (modified_image != null) {
@@ -198,11 +221,11 @@
      * Central place for retrieving images from permanent-storage locations. This is not
      * limited to this cache's local directory.
      */
-    private Gdk.Pixbuf? load_image_from_file (File image_file, Cancellable? cancellable) {
+    private async Gdk.Pixbuf? load_image_from_file_async (File image_file, Cancellable? cancellable) {
         Gdk.Pixbuf? image = null;
 
         try {
-            image = PixbufUtils.get_pixbuf_from_file (image_file, cancellable);
+            image = yield PixbufUtils.get_pixbuf_from_file_async (image_file, cancellable);
         } catch (Error err) {
             warning ("Could not get image from file [%s]: %s", image_file.get_uri (), err.message);
         }
@@ -219,7 +242,7 @@
         try {
             string path = get_cached_image_path (key);
             if (delete_file (path))
-                to_save.save (path, image_format);
+                to_save.save (path, image_format.get_name ());
         } catch (Error err) {
             warning ("Could not save pixbuf: %s", err.message);
         }

=== modified file 'src/Utils/PixbufUtils.vala'
--- src/Utils/PixbufUtils.vala	2012-09-15 07:04:34 +0000
+++ src/Utils/PixbufUtils.vala	2012-10-06 03:24:21 +0000
@@ -93,15 +93,16 @@
         return buffer_surface.load_to_pixbuf();
     }
 
-    public Gdk.Pixbuf? get_pixbuf_from_file (File file, Cancellable? c) throws Error {
-        return get_pixbuf_from_file_at_scale (file, -1, -1, false, c);
+    public async Gdk.Pixbuf? get_pixbuf_from_file_async (File file, Cancellable? c = null) throws Error {
+        return yield get_pixbuf_from_file_at_scale_async (file, -1, -1, false, c);
     }
 
-    public Gdk.Pixbuf? get_pixbuf_from_file_at_scale (File file, int width, int height,
-                                                      bool preserve_aspect_ratio,
-                                                      Cancellable? c) throws Error {
+    public async Gdk.Pixbuf? get_pixbuf_from_file_at_scale_async (File file, int width, int height,
+                                                            bool preserve_aspect_ratio,
+                                                            Cancellable? c = null) throws Error
+    {
         Gdk.Pixbuf? image = null;
-        var filestream = file.read (c);
+        var filestream = yield file.read_async (Priority.DEFAULT, c);
 
         if (filestream != null);
             image = new Gdk.Pixbuf.from_stream_at_scale (filestream, width, height,