Merge lp:~scopes-hackers/unity-lens-music/rb-scope into lp:unity-lens-music

[David Callé]

Implement a Rhythmbox scope.

Implement a Rhythmbox scope.

[Michal Hruby (mhr3)]

There are still a couple of rough edges (better album handling, monitoring changes to the xml file), but I think it's good to go in for beta2.

review: Approve

[Alex Launi (alexlauni)]

This looks pretty ok, but there's a commented out FIXME where one would launch an album, so it appears that playing an album hasn't been implemented. Did I miss something?

[Michal Hruby (mhr3)]

> This looks pretty ok, but there's a commented out FIXME where one would launch
> an album, so it appears that playing an album hasn't been implemented. Did I
> miss something?

Currently albums aren't really handled - they behave same way like the song they are "extracted" from.

[David Callé (davidc3)]

For the record, Rhythmbox doesn't provide any way to launch albums.
One solution would be, on activation of an album result, to :

rhythmbox-client --play <track1 of album>
rhythmbox-client --enqueue <track2> <track3> <track4> ...

Or, to do what the python rbox scope does :

rhythmbox-client --play <track1 of album>
and "# pray for rhythmbox to be ordered by tracks"

[Alex Launi (alexlauni)]

the first solution is what's done in banshee, and what i would suggest doing.

[Alex Launi (alexlauni)]

well, not exactly what's done in banshee but that's what i would do

[Mikkel Kamstrup Erlandsen (kamstrup)]

I took the lens for a test spin but I am not getting any results from it. Looking at the code I think everything looks alright. I am not sure what gives (and I don't get any errors on stdout).

Nice to see that all the bells and whistles of Dee is being put to use! :-D

review: Needs Fixing

[Michal Hruby (mhr3)]

Mikkel, are you running fixed Dee (the non-C-locale issue)? If not run the lens with LC_ALL=C ./...

[Mikkel Kamstrup Erlandsen (kamstrup)]

Thanks Michal, that makes it work. I think that we can bump the build dep, now that Dee has been post-release-version-bumped.

Search works nicely, but it seems that the Genre filter doesn't work?

review: Needs Fixing

[Neil J. Patel (njpatel)]

Works well for me, genres included.

review: Approve

[Mikkel Kamstrup Erlandsen (kamstrup)]

Ok, on a clean jhbuild wiht everything up-to-date this is working fine. Running well here.

review: Approve

[Unity Merger (unity-merger)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity-lens-music/10/console reported an error when processing this lp:~scopes-hackers/unity-lens-music/rb-scope branch.
Not merging it.

[Didier Roche-Tolomelli (didrocks)]

New build-dep added.

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity-lens-music/11/console reported an error when processing this lp:~scopes-hackers/unity-lens-music/rb-scope branch.
Not merging it.

[lp:~scopes-hackers/unity-lens-music/rb-scope]

102. By Michal Hruby on 2012-03-21

Update POTFILES

[Michal Hruby (mhr3)]

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2012-02-17 10:45:31 +0000
+++ configure.ac	2012-03-21 12:24:18 +0000
@@ -60,9 +60,10 @@
                   gobject-2.0 >= $GLIB_REQUIRED
                   gio-2.0 >= $GLIB_REQUIRED
                   gio-unix-2.0 >= $GLIB_REQUIRED
-                  dee-1.0 >= 0.5.16
+                  dee-1.0 >= 1.0.7
                   sqlite3 >= 3.7.7
                   gee-1.0
+                  libxml-2.0
 		  json-glib-1.0
                   unity >= 4.99.0)
 

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-01-23 13:57:10 +0000
+++ po/POTFILES.in	2012-03-21 12:24:18 +0000
@@ -1,6 +1,8 @@
 [encoding: UTF-8]
 src/daemon.vala
 src/main.vala
+src/banshee-scope.vala
+src/rhythmbox-scope.vala
 src/simple-scope.vala
 [type: gettext/ini]music.lens.in.in
 

=== modified file 'po/POTFILES.skip'
--- po/POTFILES.skip	2012-01-23 13:57:10 +0000
+++ po/POTFILES.skip	2012-03-21 12:24:18 +0000
@@ -2,3 +2,5 @@
 src/daemon.c
 src/utils.c
 src/simple-scope.c
+src/banshee-scope.c
+src/rhythmbox-scope.c

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-01-20 11:48:10 +0000
+++ src/Makefile.am	2012-03-21 12:24:18 +0000
@@ -28,6 +28,7 @@
   --pkg gio-2.0 \
   --pkg gio-unix-2.0 \
   --pkg glib-2.0 \
+  --pkg libxml-2.0 \
   $(MAINTAINER_VALAFLAGS)
 
 unity_music_daemon_LDADD = \
@@ -49,6 +50,8 @@
   filter-parser-genre.vala \
   genre.vala \
   main.vala \
+  rhythmbox-scope.vala \
+  rhythmbox-collection.vala \
   simple-scope.vala \
   track.vala \
   $(NULL)

=== modified file 'src/banshee-scope.vala'
--- src/banshee-scope.vala	2012-02-07 08:59:17 +0000
+++ src/banshee-scope.vala	2012-03-21 12:24:18 +0000
@@ -32,6 +32,7 @@
       scope = new Unity.Scope ("/com/canonical/unity/scope/banshee");
       scope.search_in_global = true;
       scope.activate_uri.connect (activate);
+      scope.sources.add_option ("banshee", _("Banshee"), null);
 
       base.initialize ();
 

=== modified file 'src/daemon.vala'
--- src/daemon.vala	2012-01-20 11:48:10 +0000
+++ src/daemon.vala	2012-03-21 12:24:18 +0000
@@ -28,20 +28,24 @@
   {
     private Unity.Lens lens;
     private BansheeScopeProxy banshee;
+    private RhythmboxScope rb;
      
     construct
     {
       banshee = new BansheeScopeProxy ();
+      rb = new RhythmboxScope ();
 
       lens = new Unity.Lens("/com/canonical/unity/lens/music", "music");
       lens.search_in_global = true;
       lens.search_hint = _("Search Music Collection");
+      lens.sources_display_name = _("Sources");
       lens.visible = true;
       
       populate_categories ();
       populate_filters();
 
       lens.add_local_scope (banshee.scope);
+      lens.add_local_scope (rb.scope);
 
       try {
         lens.export ();

=== modified file 'src/genre.vala'
--- src/genre.vala	2011-09-28 18:44:11 +0000
+++ src/genre.vala	2012-03-21 12:24:18 +0000
@@ -43,6 +43,7 @@
     public static const string OTHER_ID = "other";
 
     private static TreeMultiMap<string, string> map;
+    private static Map<string, string> inverted_map;
 
     static construct
     {
@@ -123,6 +124,16 @@
       map.set (OTHER_ID, "ambient");
       map.set (OTHER_ID, "asian");
       map.set (OTHER_ID, "brazilian");
+
+      inverted_map = new HashMap<string, string> ();
+      foreach (var key in map.get_keys ())
+      {
+        var values_collection = map[key];
+        foreach (var val in values_collection)
+        {
+          inverted_map[val] = key;
+        }
+      }
     }
 
     public Collection<string> get_genre_synonyms (string genre_id)
@@ -132,5 +143,11 @@
       
       return new LinkedList<string> ();
     }
+
+    public string get_id_for_genre (string genre)
+    {
+      return inverted_map[genre] ?? OTHER_ID;
+    }
   }
-}
\ No newline at end of file
+}
+

=== added file 'src/rhythmbox-collection.vala'
--- src/rhythmbox-collection.vala	1970-01-01 00:00:00 +0000
+++ src/rhythmbox-collection.vala	2012-03-21 12:24:18 +0000
@@ -0,0 +1,489 @@
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by David Calle <[e-mail]>
+ *             Michal Hruby <[e-mail]>
+ *
+ */
+
+using Dee;
+using Gee;
+
+namespace Unity.MusicLens
+{
+
+    private enum Columns
+    {
+        URI,
+        TITLE,
+        ARTIST,
+        ALBUM,
+        ARTWORK,
+        MIMETYPE,
+        GENRE,
+        TRACK_NUMBER,
+        ALBUM_ARTIST,
+        YEAR,
+        PLAY_COUNT
+    }
+
+    class RhythmboxCollection : Object
+    {
+
+        GenericArray<Track> tracks = new GenericArray<Track> ();
+        SequenceModel all_tracks;
+        FilterModel tracks_by_play_count;
+
+        Analyzer analyzer;
+        Index index;
+        ICUTermFilter ascii_filter;
+
+        string media_art_dir;
+
+        // contains genre maps
+        Genre genre = new Genre ();
+
+        construct
+        {
+          media_art_dir = Path.build_filename (
+              Environment.get_user_cache_dir (), "media-art");
+
+          all_tracks = new SequenceModel ();
+          // the columns correspond to the Columns enum
+          all_tracks.set_schema ("s", "s", "s", "s", "s", "s", "s", "s", "s", "i", "i");
+
+          var filter = Dee.Filter.new_sort ((row1_in, row2_in) =>
+          {
+            // magic typecasting because dee has wrong vapi (1.0.6)
+            void* row1_ptr = row1_in;
+            void* row2_ptr = row2_in;
+            unowned Variant[] row1 = (Variant[]) (row1_ptr);
+            unowned Variant[] row2 = (Variant[]) (row2_ptr);
+
+            int a = row1[Columns.PLAY_COUNT].get_int32 ();
+            int b = row2[Columns.PLAY_COUNT].get_int32 ();
+
+            return b - a; // higher play count first
+          });
+          tracks_by_play_count = new FilterModel (all_tracks, filter);
+
+          ascii_filter = new ICUTermFilter.ascii_folder ();
+          analyzer = new TextAnalyzer ();
+          analyzer.add_term_filter ((terms_in, terms_out) =>
+          {
+            foreach (unowned string term in terms_in)
+            {
+              var folded = ascii_filter.apply (term);
+              terms_out.add_term (term);
+              if (folded != term) terms_out.add_term (folded);
+            }
+          });
+          var reader = ModelReader.new ((model, iter) =>
+          {
+            var s ="%s\n%s\n%s".printf (model.get_string (iter, Columns.TITLE),
+                                        model.get_string (iter, Columns.ARTIST),
+                                        model.get_string (iter, Columns.ALBUM));
+            return s;
+          });
+
+          index = new TreeIndex (all_tracks, analyzer, reader);
+        }
+        
+        private string? get_albumart (Track track)
+        {
+            var artist = track.album_artist ?? track.artist;
+            var album = track.album;
+
+            var artist_norm = artist.normalize (-1, NormalizeMode.NFKD);
+            var album_norm = album.normalize (-1, NormalizeMode.NFKD);
+
+            var artist_md5 = Checksum.compute_for_string (ChecksumType.MD5,
+                                                          artist_norm);
+            var album_md5 = Checksum.compute_for_string (ChecksumType.MD5,
+                                                         album_norm);
+
+            string filename;
+            filename = Path.build_filename (media_art_dir,
+                "album-%s-%s".printf (artist_md5, album_md5));
+            if (FileUtils.test (filename, FileTest.EXISTS)) return filename;
+
+            var combined = "%s\t%s".printf (artist, album).normalize (-1, NormalizeMode.NFKD);
+            filename = Path.build_filename (media_art_dir,
+                "album-%s.jpg".printf (Checksum.compute_for_string (
+                    ChecksumType.MD5, combined)));
+            if (FileUtils.test (filename, FileTest.EXISTS)) return filename;
+
+            // Try Nautilus thumbnails
+            try
+            {
+                File artwork_file = File.new_for_uri (track.uri);
+                var info = artwork_file.query_info (FILE_ATTRIBUTE_THUMBNAIL_PATH, 0, null);
+                var thumbnail_path = info.get_attribute_string (FILE_ATTRIBUTE_THUMBNAIL_PATH);
+                if (thumbnail_path != null) return thumbnail_path;
+            } catch {}
+
+            // Try covers folder
+            string artwork = Path.build_filename (
+                Environment.get_user_cache_dir (), "rhythmbox", "covers",
+                "%s - %s.jpg".printf (track.artist, track.album));
+            if (FileUtils.test (artwork, FileTest.EXISTS)) return artwork;
+
+            return null;
+        }
+
+        public void parse_file (string path)
+        {
+            Xml.Parser.init ();
+
+            Xml.Doc* doc = Xml.Parser.parse_file (path);
+            if (doc == null) {
+                return;
+            }
+
+            Xml.Node* root = doc->get_root_element ();
+            if (root == null) {
+                delete doc;
+                return;
+            }
+            parse_node (root);
+            delete doc;
+
+            Xml.Parser.cleanup ();
+        }
+
+        private void parse_node (Xml.Node* node)
+        {
+            for (Xml.Node* iter = node->children; iter != null; iter = iter->next) {
+                if (iter->type != Xml.ElementType.ELEMENT_NODE) {
+                    continue;
+                }
+                for (Xml.Attr* prop = iter->properties; prop != null; prop = prop->next) {
+                    string attr_content = prop->children->content;
+                    if (attr_content == "song") {
+                        Track track = new Track ();
+              
+                        for (Xml.Node* iter_track = iter->children; iter_track != null; 
+                            iter_track = iter_track->next) {
+                            if (iter_track->type != Xml.ElementType.ELEMENT_NODE) {
+                                continue;
+                            }
+                            switch (iter_track->name) {
+                            case "title":
+                                string node_content = iter_track->get_content ();
+                                track.title = node_content;
+                                break;
+                            case "location":
+                                string node_content = iter_track->get_content ();
+                                track.uri = node_content;
+                                break;
+                            case "artist":
+                                string node_content = iter_track->get_content ();
+                                track.artist = node_content;
+                                break;
+                            case "media-type":
+                                string node_content = iter_track->get_content ();
+                                track.mime_type = node_content;
+                                break;
+                            case "album":
+                                string node_content = iter_track->get_content ();
+                                track.album = node_content;
+                                break;
+                            case "genre":
+                                string node_content = iter_track->get_content ();
+                                track.genre = node_content;
+                                break;
+                            case "track-number":
+                                string node_content = iter_track->get_content ();
+                                track.track_number = node_content;
+                                break;
+                            case "album-artist":
+                                string node_content = iter_track->get_content ();
+                                track.album_artist = node_content;
+                                break;
+                            case "date":
+                                string node_content = iter_track->get_content ();
+                                track.year = int.parse (node_content);
+                                break;
+                            case "play-count":
+                                string node_content = iter_track->get_content ();
+                                track.play_count = int.parse (node_content);
+                                break;
+                            }
+                        }
+                        // append to tracks array
+                        tracks.add (track);
+
+                        // Get cover art
+                        string albumart = get_albumart (track);
+                        if (albumart != null)
+                            track.artwork_path = albumart;
+                        else
+                            track.artwork_path = "audio-x-generic";
+                        
+                        // Get genre filter id
+                        track.genre = genre.get_id_for_genre(track.genre.down ()); 
+                        
+                        if (track.year > 0) {
+                            track.year /= 365;
+                        }
+
+                        all_tracks.append (track.uri, track.title,
+                                           track.artist, track.album,
+                                           track.artwork_path,
+                                           track.mime_type,
+                                           track.genre,
+                                           track.track_number,
+                                           track.album_artist,
+                                           track.year,
+                                           track.play_count);
+                    }
+                    // Next track
+                    parse_node (iter);
+                }
+            }
+        }
+
+        public void search (LensSearch search, 
+                            SearchType search_type, 
+                            GLib.List<FilterParser>? filters = null,
+                            int max_results = -1,
+                            int category_override = -1)
+        {
+            int num_results = 0;
+            var empty_search = search.search_string.strip () == "";
+            int min_year;
+            int max_year;
+            int category_id;
+
+            Model model = all_tracks;
+            get_decade_filter (filters, out min_year, out max_year);
+            var active_genres = get_genre_filter (filters);
+
+            if (empty_search)
+            {
+                // display a couple of most played songs
+                model = tracks_by_play_count;
+                var iter = model.get_first_iter ();
+                var end_iter = model.get_last_iter ();
+                var albums_list_nosearch = new HashSet<string> ();
+
+                while (iter != end_iter)
+                {
+                    int year = model.get_int32 (iter, Columns.YEAR);
+                    unowned string genre = model.get_string (iter, Columns.GENRE);
+
+                    // check filters
+                    if (year < min_year || year > max_year)
+                    {
+                        iter = model.next (iter);
+                        continue;
+                    }
+                    
+                    // check filters
+                    if (active_genres != null) {
+                        if (!(genre in active_genres)) {
+                            iter = model.next (iter);
+                            continue;
+                        }
+                    }
+
+                    unowned string album = model.get_string (iter,
+                                                             Columns.ALBUM);
+                    // it's not first as in track #1, but first found from album
+                    bool first_track_from_album = !(album in albums_list_nosearch);
+                    albums_list_nosearch.add (album);
+                    
+                    if (first_track_from_album)
+                    {
+                        category_id = category_override >= 0 ?
+                            category_override : Category.ALBUMS;
+
+                        search.results_model.append (
+                            model.get_string (iter, Columns.URI),
+                            model.get_string (iter, Columns.ARTWORK),
+                            category_id,
+                            model.get_string (iter, Columns.MIMETYPE),
+                            model.get_string (iter, Columns.ALBUM),
+                            model.get_string (iter, Columns.ARTIST),
+                            model.get_string (iter, Columns.URI));
+                    }
+
+                    category_id = category_override >= 0 ?
+                        category_override : Category.SONGS;
+
+                    search.results_model.append (
+                        model.get_string (iter, Columns.URI),
+                        model.get_string (iter, Columns.ARTWORK),
+                        category_id,
+                        model.get_string (iter, Columns.MIMETYPE),
+                        model.get_string (iter, Columns.TITLE),
+                        model.get_string (iter, Columns.ARTIST),
+                        model.get_string (iter, Columns.URI));
+
+                    num_results++;
+                    if (max_results >= 0 && num_results >= max_results) break;
+
+                    iter = model.next (iter);
+                }
+                return;
+            }
+
+
+            var term_list = Object.new (typeof (Dee.TermList)) as Dee.TermList;
+            // search only the folded terms, FIXME: is that a good idea?
+            analyzer.tokenize (ascii_filter.apply (search.search_string),
+                               term_list);
+
+            var matches = new Sequence<Dee.ModelIter> ();
+            bool first_pass = true;
+            foreach (unowned string term in term_list)
+            {
+                // FIXME: use PREFIX search only for the last term?
+                var result_set = index.lookup (term, TermMatchFlag.PREFIX);
+
+                CompareDataFunc<Dee.ModelIter> cmp_func = (a, b) =>
+                {
+                    return a == b ? 0 : ((void*) a > (void*) b ? 1 : -1);
+                };
+
+                // intersect the results (cause we want to AND the terms)
+                var remaining = new Sequence<Dee.ModelIter> ();
+                foreach (var item in result_set)
+                {
+                    if (first_pass)
+                        matches.insert_sorted (item, cmp_func);
+                    else if (matches.lookup (item, cmp_func) != null)
+                        remaining.insert_sorted (item, cmp_func);
+                }
+                if (!first_pass) matches = (owned) remaining;
+                // final result set empty already?
+                if (matches.get_begin_iter () == matches.get_end_iter ()) break;
+
+                first_pass = false;
+            }
+
+            // matches now contain iterators into the all_tracks model which
+            // match the search string
+            var seq_iter = matches.get_begin_iter ();
+            var seq_end_iter = matches.get_end_iter ();
+            
+            var albums_list = new HashSet<string> ();
+            while (seq_iter != seq_end_iter)
+            {
+                var model_iter = seq_iter.get ();
+                int year = model.get_int32 (model_iter, Columns.YEAR);
+                string genre = model.get_string (model_iter, Columns.GENRE);
+
+                // check filters
+                if (year < min_year || year > max_year)
+                {
+                    seq_iter = seq_iter.next ();
+                    continue;
+                }
+                
+                // check filters
+                if (active_genres != null) {
+                    bool genre_match = (genre in active_genres);
+                    if (!genre_match) {
+                        seq_iter = seq_iter.next ();
+                        continue;
+                    }
+                }
+
+                unowned string album = model.get_string (model_iter,
+                                                         Columns.ALBUM);
+                // it's not first as in track #1, but first found from album
+                bool first_track_from_album = !(album in albums_list);
+                albums_list.add (album);
+
+                if (first_track_from_album)
+                {
+                    category_id = category_override >= 0 ?
+                        category_override : Category.ALBUMS;
+
+                    search.results_model.append (
+                        model.get_string (model_iter, Columns.URI),
+                        model.get_string (model_iter, Columns.ARTWORK),
+                        category_id,
+                        model.get_string (model_iter, Columns.MIMETYPE),
+                        model.get_string (model_iter, Columns.ALBUM),
+                        model.get_string (model_iter, Columns.ARTIST),
+                        model.get_string (model_iter, Columns.URI));
+                }
+
+                category_id = category_override >= 0 ?
+                    category_override : Category.SONGS;
+
+                search.results_model.append (
+                    model.get_string (model_iter, Columns.URI),
+                    model.get_string (model_iter, Columns.ARTWORK),
+                    category_id,
+                    model.get_string (model_iter, Columns.MIMETYPE),
+                    model.get_string (model_iter, Columns.TITLE),
+                    model.get_string (model_iter, Columns.ARTIST),
+                    model.get_string (model_iter, Columns.URI));
+
+                num_results++;
+                if (max_results >= 0 && num_results >= max_results) break;
+
+                seq_iter = seq_iter.next ();
+            }
+        }
+
+        private void get_decade_filter (GLib.List<FilterParser> filters,
+                                        out int min_year, out int max_year)
+        {
+            Filter? filter = null;
+            foreach (var parser in filters)
+            {
+                if (parser is DecadeFilterParser) filter = parser.filter;
+            }
+
+            if (filter == null || !filter.filtering)
+            {
+                min_year = 0;
+                max_year = int.MAX;
+                return;
+            }
+
+            var mrf = filter as MultiRangeFilter;
+            min_year = int.parse (mrf.get_first_active ().id);
+            max_year = int.parse (mrf.get_last_active ().id);
+        }
+        
+        private Set<string>? get_genre_filter (GLib.List<FilterParser> filters)
+        {
+            Filter? filter = null;
+            foreach (var parser in filters)
+            {
+                if (parser is GenreFilterParser) filter = parser.filter;
+            }
+            if (filter == null || !filter.filtering)
+            {
+                return null;
+            }
+
+            var active_genres = new HashSet<string> ();
+            var all_genres = filter as CheckOptionFilterCompact;
+            foreach (FilterOption option in all_genres.options)
+            {
+                if (option.id == null || !option.active) continue;
+                active_genres.add (option.id);
+            }
+
+            return active_genres;
+        }
+    }
+}

=== added file 'src/rhythmbox-scope.vala'
--- src/rhythmbox-scope.vala	1970-01-01 00:00:00 +0000
+++ src/rhythmbox-scope.vala	2012-03-21 12:24:18 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Alex Launi <[e-mail]>
+ *
+ */
+
+using GLib;
+
+namespace Unity.MusicLens {
+     
+  public class RhythmboxScope : SimpleScope
+  { 
+    private RhythmboxCollection collection;
+    private bool db_ready;
+
+    public RhythmboxScope ()
+    {
+      base ();
+
+      scope = new Unity.Scope ("/com/canonical/unity/scope/rhythmbox");
+      scope.search_in_global = true;
+      scope.activate_uri.connect (activate);
+      scope.sources.add_option ("rhythmbox", _("Rhythmbox"), null);
+
+      base.initialize ();
+      collection = new RhythmboxCollection ();
+      db_ready = false;
+    }
+
+    protected override int num_results_without_search { get {return 100; } }
+    protected override int num_results_global_search { get { return 20; } }
+    protected override int num_results_lens_search { get { return 50; } }
+
+    /**
+     * Tells banshee to play the selected uri(s)
+     */
+    public Unity.ActivationResponse activate (string uri)
+    {
+      string[] exec = {"rhythmbox-client", "--play-uri"};
+
+      try {
+        if (Uri.parse_scheme (uri) == "album")
+          {
+            debug (@"searching for tracks for $uri");
+            string[] split = uri.split ("/");
+            string artist = split[2];
+            string title = split[3];
+        
+            Album album = new Album ();
+            album.artist = artist;
+            album.title = title;
+            // FIXME there must be a better way..
+//            foreach (string track in collection.get_track_uris (album))
+//              exec += track;
+          }
+        else
+          {
+            exec += uri;
+          }
+    
+        exec += null;
+    
+        debug ("Spawning rb '%s'", string.joinv (" ", exec));
+        Process.spawn_async (null, 
+                 exec,
+                 null, 
+                 SpawnFlags.SEARCH_PATH,
+                 null, 
+                 null);
+    
+        return new Unity.ActivationResponse (Unity.HandledType.HIDE_DASH);
+      } catch (SpawnError error) {
+        warning ("Failed to launch URI %s", uri);
+        return new Unity.ActivationResponse (Unity.HandledType.NOT_HANDLED);
+      }
+    }
+
+    public override async void perform_search (LensSearch search,
+                                               SearchType search_type, 
+                                               owned List<FilterParser> filters,
+                                               int max_results = -1,
+                                               Cancellable? cancellable = null)
+    {
+      int category_override = -1;
+      if (search_type == SearchType.GLOBAL)
+      {
+        category_override = Category.MUSIC;
+        // the lens shouldn't display anything for empty search
+        if (is_search_empty (search)) return;
+      }
+
+      if (!db_ready)
+      {
+        // parse the DB lazily
+        collection.parse_file ("%s/.local/share/rhythmbox/rhythmdb.xml".printf (Environment.get_home_dir ()));
+        db_ready = true;
+      }
+
+      collection.search (search, search_type, filters,
+                         max_results, category_override);
+    }
+  }
+}

=== modified file 'src/simple-scope.vala'
--- src/simple-scope.vala	2012-02-07 08:59:17 +0000
+++ src/simple-scope.vala	2012-03-21 12:24:18 +0000
@@ -46,6 +46,10 @@
         scope.queue_search_changed (SearchType.DEFAULT);
       });
 
+      scope.active_sources_changed.connect (() => {
+        scope.queue_search_changed (SearchType.DEFAULT);
+      });
+
       /* No need to search if only the whitespace changes */
       scope.generate_search_key.connect ((lens_search) => {
         return lens_search.search_string.strip ();
@@ -98,6 +102,21 @@
 
       results_model.clear ();
 
+      // don't perform search is all sources are inactive
+      if (scope.sources.options.length () > 0 && scope.sources.filtering)
+      {
+        bool any_active = false;
+        foreach (var source in scope.sources.options)
+        {
+          if (source.active) any_active = true;
+        }
+        if (!any_active)
+        {
+          search.finished ();
+          return;
+        }
+      }
+
       yield perform_search (search, search_type, (owned) filters, max_results, cancellable);
 
       if (results_model.get_n_rows () == 0)

=== modified file 'src/track.vala'
--- src/track.vala	2011-09-14 18:33:52 +0000
+++ src/track.vala	2012-03-21 12:24:18 +0000
@@ -26,5 +26,11 @@
     public string artist { get; set; }
     public string mime_type { get; set; }
     public string artwork_path { get; set; }
+    public string album { get; set; }
+    public string album_artist { get; set; }
+    public string genre { get; set; }
+    public string track_number { get; set; }
+    public int year { get; set; }
+    public int play_count { get; set; }
   }
-}
\ No newline at end of file
+}