Merge lp:~jamesh/mediascanner2/media-filter into lp:mediascanner2

[James Henstridge]

Introduce a mediascanner::Filter type to hold search parameters for the various MediaStore::list*() methods, and expand them to handle genres. The new API also distinguishes between an unset filter and a filter set to "". Make similar changes to the QML API, and add notify signals to the rowCount properties.

Introduce a mediascanner::Filter type to hold search parameters for the various MediaStore::list*() methods, and expand them to handle genres. The new API also distinguishes between an unset filter and a filter set to "". Make similar changes to the QML API, and add notify signals to the rowCount properties.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:267
http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/81/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-armhf-ci/22
        deb: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-armhf-ci/22/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-i386-ci/22

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mediascanner2-ci/81/rebuild

review: Approve (continuous-integration)

=== modified file 'src/mediascanner/CMakeLists.txt'
--- src/mediascanner/CMakeLists.txt	2014-05-29 09:17:39 +0000
+++ src/mediascanner/CMakeLists.txt	2014-05-29 09:17:39 +0000
@@ -2,6 +2,7 @@
   MediaFile.cc
   MediaFileBuilder.cc
   MediaFilePrivate.cc
+  Filter.cc
   Album.cc
   MediaStore.cc
   utils.cc

=== added file 'src/mediascanner/Filter.cc'
--- src/mediascanner/Filter.cc	1970-01-01 00:00:00 +0000
+++ src/mediascanner/Filter.cc	2014-05-29 09:17:39 +0000
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Filter.hh"
+
+using std::string;
+
+namespace mediascanner {
+
+struct Filter::Private {
+    string artist;
+    string album;
+    string album_artist;
+    string genre;
+
+    bool have_artist;
+    bool have_album;
+    bool have_album_artist;
+    bool have_genre;
+
+    Private() :
+        have_artist(false), have_album(false), have_album_artist(false),
+        have_genre(false) {
+    }
+};
+
+Filter::Filter() : p(new Private) {
+}
+
+Filter::Filter(const Filter &other) : Filter() {
+    *p = *other.p;
+}
+
+Filter::~Filter() {
+    delete p;
+}
+
+bool Filter::operator==(const Filter &other) const {
+    return
+        p->have_artist == other.p->have_artist &&
+        p->have_album == other.p->have_album &&
+        p->have_album_artist == other.p->have_album_artist &&
+        p->have_genre == other.p->have_genre &&
+        p->artist == other.p->artist &&
+        p->album == other.p->album &&
+        p->album_artist == other.p->album_artist &&
+        p->genre == other.p->genre;
+}
+
+bool Filter::operator!=(const Filter &other) const {
+    return !(*this == other);
+}
+
+Filter &Filter::operator=(const Filter &other) {
+    *p = *other.p;
+    return *this;
+}
+
+void Filter::clear() {
+    unsetArtist();
+    unsetAlbum();
+    unsetAlbumArtist();
+    unsetGenre();
+}
+
+void Filter::setArtist(const std::string &artist) {
+    p->artist = artist;
+    p->have_artist = true;
+}
+
+void Filter::unsetArtist() {
+    p->artist = "";
+    p->have_artist = false;
+}
+
+bool Filter::hasArtist() const {
+    return p->have_artist;
+}
+
+const std::string &Filter::getArtist() const {
+    return p->artist;
+}
+
+void Filter::setAlbum(const std::string &album) {
+    p->album = album;
+    p->have_album = true;
+}
+
+void Filter::unsetAlbum() {
+    p->album = "";
+    p->have_album = false;
+}
+
+bool Filter::hasAlbum() const {
+    return p->have_album;
+}
+
+const std::string &Filter::getAlbum() const {
+    return p->album;
+}
+
+void Filter::setAlbumArtist(const std::string &album_artist) {
+    p->album_artist = album_artist;
+    p->have_album_artist = true;
+}
+
+void Filter::unsetAlbumArtist() {
+    p->album_artist = "";
+    p->have_album_artist = false;
+}
+
+bool Filter::hasAlbumArtist() const {
+    return p->have_album_artist;
+}
+
+const std::string &Filter::getAlbumArtist() const {
+    return p->album_artist;
+}
+
+void Filter::setGenre(const std::string &genre) {
+    p->genre = genre;
+    p->have_genre = true;
+}
+
+void Filter::unsetGenre() {
+    p->genre = "";
+    p->have_genre = false;
+}
+
+bool Filter::hasGenre() const {
+    return p->have_genre;
+}
+
+const std::string &Filter::getGenre() const {
+    return p->genre;
+}
+
+}

=== added file 'src/mediascanner/Filter.hh'
--- src/mediascanner/Filter.hh	1970-01-01 00:00:00 +0000
+++ src/mediascanner/Filter.hh	2014-05-29 09:17:39 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MEDIAFILTER_H_
+#define MEDIAFILTER_H_
+
+#include <string>
+
+namespace mediascanner {
+
+class Filter final {
+public:
+    Filter();
+    Filter(const Filter &other);
+    ~Filter();
+
+    Filter &operator=(const Filter &other);
+    bool operator==(const Filter &other) const;
+    bool operator!=(const Filter &other) const;
+
+    void clear();
+
+    void setArtist(const std::string &artist);
+    void unsetArtist();
+    bool hasArtist() const;
+    const std::string &getArtist() const;
+
+    void setAlbum(const std::string &album);
+    void unsetAlbum();
+    bool hasAlbum() const;
+    const std::string &getAlbum() const;
+
+    void setAlbumArtist(const std::string &album_artist);
+    void unsetAlbumArtist();
+    bool hasAlbumArtist() const;
+    const std::string &getAlbumArtist() const;
+
+    void setGenre(const std::string &genre);
+    void unsetGenre();
+    bool hasGenre() const;
+    const std::string &getGenre() const;
+
+private:
+    struct Private;
+    Private *p;
+};
+
+}
+
+#endif

=== modified file 'src/mediascanner/MediaStore.cc'
--- src/mediascanner/MediaStore.cc	2014-05-29 09:17:39 +0000
+++ src/mediascanner/MediaStore.cc	2014-05-29 09:17:39 +0000
@@ -33,6 +33,7 @@
 #include "MediaFile.hh"
 #include "MediaFileBuilder.hh"
 #include "Album.hh"
+#include "Filter.hh"
 #include "internal/sqliteutils.hh"
 #include "internal/utils.hh"
 
@@ -448,21 +449,24 @@
     }
 }
 
-std::vector<MediaFile> MediaStore::listSongs(const std::string& artist, const std::string& album, const std::string& album_artist, int limit) const {
+std::vector<MediaFile> MediaStore::listSongs(const Filter &filter, int limit) const {
     std::string qs(R"(
 SELECT filename, content_type, etag, title, date, artist, album, album_artist, genre, disc_number, track_number, duration, type
   FROM media
   WHERE type = ?
 )");
-    if (!artist.empty()) {
+    if (filter.hasArtist()) {
         qs += " AND artist = ?";
     }
-    if (!album.empty()) {
+    if (filter.hasAlbum()) {
         qs += " AND album = ?";
     }
-    if (!album_artist.empty()) {
+    if (filter.hasAlbumArtist()) {
         qs += " AND album_artist = ?";
     }
+    if (filter.hasGenre()) {
+        qs += " AND genre = ?";
+    }
     qs += R"(
 ORDER BY album_artist, album, disc_number, track_number, title
 LIMIT ?
@@ -470,31 +474,37 @@
     Statement query(p->db, qs.c_str());
     int param = 1;
     query.bind(param++, (int)AudioMedia);
-    if (!artist.empty()) {
-        query.bind(param++, artist);
-    }
-    if (!album.empty()) {
-        query.bind(param++, album);
-    }
-    if (!album_artist.empty()) {
-        query.bind(param++, album_artist);
+    if (filter.hasArtist()) {
+        query.bind(param++, filter.getArtist());
+    }
+    if (filter.hasAlbum()) {
+        query.bind(param++, filter.getAlbum());
+    }
+    if (filter.hasAlbumArtist()) {
+        query.bind(param++, filter.getAlbumArtist());
+    }
+    if (filter.hasGenre()) {
+        query.bind(param++, filter.getGenre());
     }
     query.bind(param++, limit);
 
     return collect_media(query);
 }
 
-std::vector<Album> MediaStore::listAlbums(const std::string& artist, const std::string& album_artist, int limit) const {
+std::vector<Album> MediaStore::listAlbums(const Filter &filter, int limit) const {
     std::string qs(R"(
 SELECT album, album_artist FROM media
   WHERE type = ?
 )");
-    if (!artist.empty()) {
+    if (filter.hasArtist()) {
         qs += " AND artist = ?";
     }
-    if (!album_artist.empty()) {
+    if (filter.hasAlbumArtist()) {
         qs += " AND album_artist = ?";
     }
+    if (filter.hasGenre()) {
+        qs += "AND genre = ?";
+    }
     qs += R"(
 GROUP BY album, album_artist
 ORDER BY album_artist, album
@@ -503,37 +513,68 @@
     Statement query(p->db, qs.c_str());
     int param = 1;
     query.bind(param++, (int)AudioMedia);
-    if (!artist.empty()) {
-        query.bind(param++, artist);
-    }
-    if (!album_artist.empty()) {
-        query.bind(param++, album_artist);
+    if (filter.hasArtist()) {
+        query.bind(param++, filter.getArtist());
+    }
+    if (filter.hasAlbumArtist()) {
+        query.bind(param++, filter.getAlbumArtist());
+    }
+    if (filter.hasGenre()) {
+        query.bind(param++, filter.getGenre());
     }
     query.bind(param++, limit);
 
     return collect_albums(query);
 }
 
-vector<std::string> MediaStore::listArtists(bool album_artists, int limit) const {
-    const char *qs;
-
-    if (album_artists) {
-        qs = R"(
+vector<std::string> MediaStore::listArtists(const Filter &filter, int limit) const {
+    string qs(R"(
+SELECT artist FROM media
+  WHERE type = ?
+)");
+    if (filter.hasGenre()) {
+        qs += " AND genre = ?";
+    }
+    qs += R"(
+  GROUP BY artist
+  ORDER BY artist
+  LIMIT ?
+)";
+    Statement query(p->db, qs.c_str());
+    int param = 1;
+    query.bind(param++, (int)AudioMedia);
+    if (filter.hasGenre()) {
+        query.bind(param++, filter.getGenre());
+    }
+    query.bind(param++, limit);
+
+    vector<string> artists;
+    while (query.step()) {
+        artists.push_back(query.getText(0));
+    }
+    return artists;
+}
+
+vector<std::string> MediaStore::listAlbumArtists(const Filter &filter, int limit) const {
+    string qs(R"(
 SELECT album_artist FROM media
+  WHERE type = ?
+)");
+    if (filter.hasGenre()) {
+        qs += " AND genre = ?";
+    }
+    qs += R"(
   GROUP BY album_artist
   ORDER BY album_artist
   LIMIT ?
 )";
-    } else {
-        qs = R"(
-SELECT artist FROM media
-  GROUP BY artist
-  ORDER BY artist
-  LIMIT ?
-)";
+    Statement query(p->db, qs.c_str());
+    int param = 1;
+    query.bind(param++, (int)AudioMedia);
+    if (filter.hasGenre()) {
+        query.bind(param++, filter.getGenre());
     }
-    Statement query(p->db, qs);
-    query.bind(1, limit);
+    query.bind(param++, limit);
 
     vector<string> artists;
     while (query.step()) {
@@ -542,6 +583,24 @@
     return artists;
 }
 
+vector<std::string> MediaStore::listGenres(int limit) const {
+    Statement query(p->db, R"(
+SELECT genre FROM media
+  WHERE type = ?
+  GROUP BY genre
+  ORDER BY genre
+  LIMIT ?
+)");
+    query.bind(1, (int)AudioMedia);
+    query.bind(2, limit);
+
+    vector<string> genres;
+    while (query.step()) {
+        genres.push_back(query.getText(0));
+    }
+    return genres;
+}
+
 void MediaStorePrivate::pruneDeleted() {
     vector<string> deleted;
     Statement query(db, "SELECT filename FROM media");

=== modified file 'src/mediascanner/MediaStore.hh'
--- src/mediascanner/MediaStore.hh	2014-05-29 09:17:39 +0000
+++ src/mediascanner/MediaStore.hh	2014-05-29 09:17:39 +0000
@@ -29,6 +29,7 @@
 struct MediaStorePrivate;
 class MediaFile;
 class Album;
+class Filter;
 
 enum OpenType {
     MS_READ_ONLY,
@@ -53,9 +54,11 @@
     std::vector<Album> queryAlbums(const std::string &core_term, int limit=-1) const;
     std::vector<MediaFile> getAlbumSongs(const Album& album) const;
     std::string getETag(const std::string &filename) const;
-    std::vector<MediaFile> listSongs(const std::string& artist="", const std::string& album="", const std::string& album_artist="", int limit=-1) const;
-    std::vector<Album> listAlbums(const std::string& artist="", const std::string& album_artist="", int limit=-1) const;
-    std::vector<std::string> listArtists(bool album_artists, int limit=-1) const;
+    std::vector<MediaFile> listSongs(const Filter &filter, int limit=-1) const;
+    std::vector<Album> listAlbums(const Filter &filter, int limit=-1) const;
+    std::vector<std::string> listArtists(const Filter &filter, int limit=-1) const;
+    std::vector<std::string>listAlbumArtists(const Filter &filter, int limit=-1) const;
+    std::vector<std::string>listGenres(int limit=-1) const;
 
     size_t size() const;
     void pruneDeleted();

=== modified file 'src/ms-dbus/dbus-codec.cc'
--- src/ms-dbus/dbus-codec.cc	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/dbus-codec.cc	2014-05-29 09:17:39 +0000
@@ -24,6 +24,7 @@
 #include <mediascanner/MediaFile.hh>
 #include <mediascanner/MediaFileBuilder.hh>
 #include <mediascanner/Album.hh>
+#include <mediascanner/Filter.hh>
 #include "dbus-codec.hh"
 
 using core::dbus::Message;
@@ -32,6 +33,7 @@
 using mediascanner::MediaFileBuilder;
 using mediascanner::MediaType;
 using mediascanner::Album;
+using mediascanner::Filter;
 using std::string;
 
 void Codec<MediaFile>::encode_argument(Message::Writer &out, const MediaFile &file) {
@@ -88,3 +90,46 @@
     r >> title >> artist;
     album = Album(title, artist);
 }
+
+void Codec<Filter>::encode_argument(Message::Writer &out, const Filter &filter) {
+    auto w = out.open_array(core::dbus::types::Signature("{ss}"));
+
+    if (filter.hasArtist()) {
+        w.close_dict_entry(
+            w.open_dict_entry() << string("artist") << filter.getArtist());
+    }
+    if (filter.hasAlbum()) {
+        w.close_dict_entry(
+            w.open_dict_entry() << string("album") << filter.getAlbum());
+    }
+    if (filter.hasAlbumArtist()) {
+        w.close_dict_entry(
+            w.open_dict_entry() << string("album_artist") << filter.getAlbumArtist());
+    }
+    if (filter.hasGenre()) {
+        w.close_dict_entry(
+            w.open_dict_entry() << string("genre") << filter.getGenre());
+    }
+
+    out.close_array(std::move(w));
+}
+
+void Codec<Filter>::decode_argument(Message::Reader &in, Filter &filter) {
+    auto r = in.pop_array();
+
+    filter.clear();
+    while (r.type() != ArgumentType::invalid) {
+        string key, value;
+        r.pop_dict_entry() >> key >> value;
+
+        if (key == "artist") {
+            filter.setArtist(value);
+        } else if (key == "album") {
+            filter.setAlbum(value);
+        } else if (key == "album_artist") {
+            filter.setAlbumArtist(value);
+        } else if (key == "genre") {
+            filter.setGenre(value);
+        }
+    }
+}

=== modified file 'src/ms-dbus/dbus-codec.hh'
--- src/ms-dbus/dbus-codec.hh	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/dbus-codec.hh	2014-05-29 09:17:39 +0000
@@ -27,6 +27,7 @@
 namespace mediascanner {
 class MediaFile;
 class Album;
+class Filter;
 }
 
 namespace core {
@@ -44,6 +45,12 @@
     static void decode_argument(Message::Reader &in, mediascanner::Album &album);
 };
 
+template <>
+struct Codec<mediascanner::Filter> {
+    static void encode_argument(Message::Writer &out, const mediascanner::Filter &filter);
+    static void decode_argument(Message::Reader &in, mediascanner::Filter &filter);
+};
+
 namespace helper {
 
 template<>
@@ -80,6 +87,23 @@
     }
 };
 
+template<>
+struct TypeMapper<mediascanner::Filter> {
+    constexpr static ArgumentType type_value() {
+        return ArgumentType::array;
+    }
+    constexpr static bool is_basic_type() {
+        return false;
+    }
+    constexpr static bool requires_signature() {
+        return true;
+    }
+    static const std::string &signature() {
+        static const std::string s = "a{ss}";
+        return s;
+    }
+};
+
 }
 
 }

=== modified file 'src/ms-dbus/dbus-interface.hh'
--- src/ms-dbus/dbus-interface.hh	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/dbus-interface.hh	2014-05-29 09:17:39 +0000
@@ -153,6 +153,32 @@
             return std::chrono::seconds{1};
         }
     };
+
+    struct ListAlbumArtists {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "ListAlbumArtists";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct ListGenres {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "ListGenres";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
 };
 
 }

=== modified file 'src/ms-dbus/service-skeleton.cc'
--- src/ms-dbus/service-skeleton.cc	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/service-skeleton.cc	2014-05-29 09:17:39 +0000
@@ -6,6 +6,7 @@
 #include <sys/apparmor.h>
 
 #include <mediascanner/Album.hh>
+#include <mediascanner/Filter.hh>
 #include <mediascanner/MediaFile.hh>
 #include <mediascanner/MediaStore.hh>
 
@@ -88,6 +89,16 @@
                 &Private::handle_list_artists,
                 this,
                 std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::ListAlbumArtists>(
+            std::bind(
+                &Private::handle_list_album_artists,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::ListGenres>(
+            std::bind(
+                &Private::handle_list_genres,
+                this,
+                std::placeholders::_1));
     }
 
     std::string get_client_apparmor_context(const Message::Ptr &message) {
@@ -253,12 +264,12 @@
         if (!check_access(message, AudioMedia))
             return;
 
-        std::string artist, album, album_artist;
+        Filter filter;
         int32_t limit;
-        message->reader() >> artist >> album >> album_artist >> limit;
+        message->reader() >> filter >> limit;
         Message::Ptr reply;
         try {
-            auto results = store->listSongs(artist, album, album_artist, limit);
+            auto results = store->listSongs(filter, limit);
             reply = Message::make_method_return(message);
             reply->writer() << results;
         } catch (const std::exception &e) {
@@ -273,12 +284,12 @@
         if (!check_access(message, AudioMedia))
             return;
 
-        std::string artist, album_artist;
+        Filter filter;
         int32_t limit;
-        message->reader() >> artist >> album_artist >> limit;
+        message->reader() >> filter >> limit;
         Message::Ptr reply;
         try {
-            auto albums = store->listAlbums(artist, album_artist, limit);
+            auto albums = store->listAlbums(filter, limit);
             reply = Message::make_method_return(message);
             reply->writer() << albums;
         } catch (const std::exception &e) {
@@ -293,14 +304,53 @@
         if (!check_access(message, AudioMedia))
             return;
 
-        bool album_artists;
-        int32_t limit;
-        message->reader() >> album_artists >> limit;
-        Message::Ptr reply;
-        try {
-            auto artists = store->listArtists(album_artists, limit);
-            reply = Message::make_method_return(message);
-            reply->writer() << artists;
+        Filter filter;
+        int32_t limit;
+        message->reader() >> filter >> limit;
+        Message::Ptr reply;
+        try {
+            auto artists = store->listArtists(filter, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << artists;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_list_album_artists(const Message::Ptr &message) {
+        if (!check_access(message, AudioMedia))
+            return;
+
+        Filter filter;
+        int32_t limit;
+        message->reader() >> filter >> limit;
+        Message::Ptr reply;
+        try {
+            auto artists = store->listAlbumArtists(filter, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << artists;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_list_genres(const Message::Ptr &message) {
+        if (!check_access(message, AudioMedia))
+            return;
+
+        int32_t limit;
+        message->reader() >> limit;
+        Message::Ptr reply;
+        try {
+            auto genres = store->listGenres(limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << genres;
         } catch (const std::exception &e) {
             reply = Message::make_error(
                 message, MediaStoreInterface::Errors::Error::name(),

=== modified file 'src/ms-dbus/service-stub.cc'
--- src/ms-dbus/service-stub.cc	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/service-stub.cc	2014-05-29 09:17:39 +0000
@@ -20,6 +20,7 @@
 #include <stdexcept>
 
 #include <mediascanner/Album.hh>
+#include <mediascanner/Filter.hh>
 #include <mediascanner/MediaFile.hh>
 #include "service-stub.hh"
 #include "dbus-interface.hh"
@@ -79,21 +80,35 @@
     return result.value();
 }
 
-std::vector<MediaFile> ServiceStub::listSongs(const string &artist, const string &album, const string &album_artist, int limit) const {
-    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListSongs, std::vector<MediaFile>>(artist, album, album_artist, (int32_t)limit);
-    if (result.is_error())
-        throw std::runtime_error(result.error().print());
-    return result.value();
-}
-
-std::vector<Album> ServiceStub::listAlbums(const string &artist, const string &album_artist, int limit) const {
-    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListAlbums, std::vector<Album>>(artist, album_artist, (int32_t)limit);
-    if (result.is_error())
-        throw std::runtime_error(result.error().print());
-    return result.value();
-}
-std::vector<string> ServiceStub::listArtists(bool album_artists, int limit) const {
-    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListArtists, std::vector<string>>(album_artists, (int32_t)limit);
+std::vector<MediaFile> ServiceStub::listSongs(const Filter &filter, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListSongs, std::vector<MediaFile>>(filter, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<Album> ServiceStub::listAlbums(const Filter &filter, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListAlbums, std::vector<Album>>(filter, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+std::vector<string> ServiceStub::listArtists(const Filter &filter, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListArtists, std::vector<string>>(filter, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<string> ServiceStub::listAlbumArtists(const Filter &filter, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListAlbumArtists, std::vector<string>>(filter, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<string> ServiceStub::listGenres(int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::ListGenres, std::vector<string>>((int32_t)limit);
     if (result.is_error())
         throw std::runtime_error(result.error().print());
     return result.value();

=== modified file 'src/ms-dbus/service-stub.hh'
--- src/ms-dbus/service-stub.hh	2014-05-29 09:17:39 +0000
+++ src/ms-dbus/service-stub.hh	2014-05-29 09:17:39 +0000
@@ -32,6 +32,7 @@
 namespace mediascanner {
 
 class Album;
+class Filter;
 class MediaFile;
 
 namespace dbus {
@@ -46,9 +47,11 @@
     std::vector<Album> queryAlbums(const std::string &core_term, int limit=-1) const;
     std::vector<MediaFile> getAlbumSongs(const Album& album) const;
     std::string getETag(const std::string &filename) const;
-    std::vector<MediaFile> listSongs(const std::string& artist="", const std::string& album="", const std::string& album_artist="", int limit=-1) const;
-    std::vector<Album> listAlbums(const std::string& artist="", const std::string& album_artist="", int limit=-1) const;
-    std::vector<std::string> listArtists(bool album_artists, int limit=-1) const;
+    std::vector<MediaFile> listSongs(const Filter &filter, int limit=-1) const;
+    std::vector<Album> listAlbums(const Filter &filter, int limit=-1) const;
+    std::vector<std::string> listArtists(const Filter &filter, int limit=-1) const;
+    std::vector<std::string> listAlbumArtists(const Filter &filter, int limit=-1) const;
+    std::vector<std::string> listGenres(int limit=-1) const;
 
 private:
     struct Private;

=== modified file 'src/qml/Ubuntu/MediaScanner/AlbumModelBase.cc'
--- src/qml/Ubuntu/MediaScanner/AlbumModelBase.cc	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/AlbumModelBase.cc	2014-05-29 09:17:39 +0000
@@ -62,4 +62,5 @@
     beginResetModel();
     this->results = results;
     endResetModel();
+    Q_EMIT rowCountChanged();
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/AlbumModelBase.hh'
--- src/qml/Ubuntu/MediaScanner/AlbumModelBase.hh	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/AlbumModelBase.hh	2014-05-29 09:17:39 +0000
@@ -31,7 +31,7 @@
 class AlbumModelBase : public QAbstractListModel {
     Q_OBJECT
     Q_ENUMS(Roles)
-    Q_PROPERTY(int rowCount READ rowCount) // NOTIFY modelReset
+    Q_PROPERTY(int rowCount READ rowCount NOTIFY rowCountChanged)
 public:
     enum Roles {
         RoleTitle,
@@ -44,6 +44,8 @@
     QVariant data(const QModelIndex &index, int role) const override;
 
     Q_INVOKABLE QVariant get(int row, Roles role) const;
+Q_SIGNALS:
+    void rowCountChanged();
 protected:
     QHash<int, QByteArray> roleNames() const override;
     void updateResults(const std::vector<mediascanner::Album> &results);

=== modified file 'src/qml/Ubuntu/MediaScanner/AlbumsModel.cc'
--- src/qml/Ubuntu/MediaScanner/AlbumsModel.cc	2014-02-27 07:02:21 +0000
+++ src/qml/Ubuntu/MediaScanner/AlbumsModel.cc	2014-05-29 09:17:39 +0000
@@ -24,8 +24,6 @@
 AlbumsModel::AlbumsModel(QObject *parent)
     : AlbumModelBase(parent),
       store(nullptr),
-      artist(""),
-      album_artist(""),
       limit(-1) {
 }
 
@@ -40,25 +38,66 @@
     }
 }
 
-QString AlbumsModel::getArtist() {
-    return artist;
-}
-
-void AlbumsModel::setArtist(const QString artist) {
-    if (this->artist != artist) {
-        this->artist = artist;
-        update();
-    }
-}
-
-QString AlbumsModel::getAlbumArtist() {
-    return album_artist;
-}
-
-void AlbumsModel::setAlbumArtist(const QString album_artist) {
-    if (this->album_artist != album_artist) {
-        this->album_artist = album_artist;
-        update();
+QVariant AlbumsModel::getArtist() {
+    if (!filter.hasArtist())
+        return QVariant();
+    return QString::fromStdString(filter.getArtist());
+}
+
+void AlbumsModel::setArtist(const QVariant artist) {
+    if (artist.isNull()) {
+        if (filter.hasArtist()) {
+            filter.unsetArtist();
+            update();
+        }
+    } else {
+        const std::string std_artist = artist.value<QString>().toStdString();
+        if (!filter.hasArtist() || filter.getArtist() != std_artist) {
+            filter.setArtist(std_artist);
+            update();
+        }
+    }
+}
+
+QVariant AlbumsModel::getAlbumArtist() {
+    if (!filter.hasAlbumArtist())
+        return QVariant();
+    return QString::fromStdString(filter.getAlbumArtist());
+}
+
+void AlbumsModel::setAlbumArtist(const QVariant album_artist) {
+    if (album_artist.isNull()) {
+        if (filter.hasAlbumArtist()) {
+            filter.unsetAlbumArtist();
+            update();
+        }
+    } else {
+        const std::string std_album_artist = album_artist.value<QString>().toStdString();
+        if (!filter.hasAlbumArtist() || filter.getAlbumArtist() != std_album_artist) {
+            filter.setAlbumArtist(std_album_artist);
+            update();
+        }
+    }
+}
+
+QVariant AlbumsModel::getGenre() {
+    if (!filter.hasGenre())
+        return QVariant();
+    return QString::fromStdString(filter.getGenre());
+}
+
+void AlbumsModel::setGenre(const QVariant genre) {
+    if (genre.isNull()) {
+        if (filter.hasGenre()) {
+            filter.unsetGenre();
+            update();
+        }
+    } else {
+        const std::string std_genre = genre.value<QString>().toStdString();
+        if (!filter.hasGenre() || filter.getGenre() != std_genre) {
+            filter.setGenre(std_genre);
+            update();
+        }
     }
 }
 
@@ -77,6 +116,6 @@
     if (store == nullptr) {
         updateResults(std::vector<mediascanner::Album>());
     } else {
-        updateResults(store->store.listAlbums(artist.toStdString(), album_artist.toStdString(), limit));
+        updateResults(store->store.listAlbums(filter, limit));
     }
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/AlbumsModel.hh'
--- src/qml/Ubuntu/MediaScanner/AlbumsModel.hh	2014-02-27 07:02:21 +0000
+++ src/qml/Ubuntu/MediaScanner/AlbumsModel.hh	2014-05-29 09:17:39 +0000
@@ -22,6 +22,7 @@
 
 #include <QString>
 
+#include <mediascanner/Filter.hh>
 #include "MediaStoreWrapper.hh"
 #include "AlbumModelBase.hh"
 
@@ -31,8 +32,9 @@
 class AlbumsModel : public AlbumModelBase {
     Q_OBJECT
     Q_PROPERTY(mediascanner::qml::MediaStoreWrapper* store READ getStore WRITE setStore)
-    Q_PROPERTY(QString artist READ getArtist WRITE setArtist)
-    Q_PROPERTY(QString albumArtist READ getAlbumArtist WRITE setAlbumArtist)
+    Q_PROPERTY(QVariant artist READ getArtist WRITE setArtist)
+    Q_PROPERTY(QVariant albumArtist READ getAlbumArtist WRITE setAlbumArtist)
+    Q_PROPERTY(QVariant genre READ getGenre WRITE setGenre)
     Q_PROPERTY(int limit READ getLimit WRITE setLimit)
 public:
     explicit AlbumsModel(QObject *parent=0);
@@ -40,17 +42,19 @@
     MediaStoreWrapper *getStore();
     void setStore(MediaStoreWrapper *store);
 
-    QString getArtist();
-    void setArtist(const QString artist);
-    QString getAlbumArtist();
-    void setAlbumArtist(const QString album_artist);
+    QVariant getArtist();
+    void setArtist(const QVariant artist);
+    QVariant getAlbumArtist();
+    void setAlbumArtist(const QVariant album_artist);
+    QVariant getGenre();
+    void setGenre(const QVariant genre);
     int getLimit();
     void setLimit(int limit);
 private:
     void update();
 
     MediaStoreWrapper *store;
-    QString artist, album_artist;
+    Filter filter;
     int limit;
 };
 

=== modified file 'src/qml/Ubuntu/MediaScanner/ArtistsModel.cc'
--- src/qml/Ubuntu/MediaScanner/ArtistsModel.cc	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/ArtistsModel.cc	2014-05-29 09:17:39 +0000
@@ -75,6 +75,27 @@
     }
 }
 
+QVariant ArtistsModel::getGenre() {
+    if (!filter.hasGenre())
+        return QVariant();
+    return QString::fromStdString(filter.getGenre());
+}
+
+void ArtistsModel::setGenre(const QVariant genre) {
+    if (genre.isNull()) {
+        if (filter.hasGenre()) {
+            filter.unsetGenre();
+            update();
+        }
+    } else {
+        const std::string std_genre = genre.value<QString>().toStdString();
+        if (!filter.hasGenre() || filter.getGenre() != std_genre) {
+            filter.setGenre(std_genre);
+            update();
+        }
+    }
+}
+
 int ArtistsModel::getLimit() {
     return limit;
 }
@@ -91,8 +112,12 @@
     if (store == nullptr) {
         this->results.clear();
     } else {
-        this->results = store->store.listArtists(album_artists, limit);
+        if (album_artists) {
+            this->results = store->store.listAlbumArtists(filter, limit);
+        } else {
+            this->results = store->store.listArtists(filter, limit);
+        }
     }
-    this->results = results;
     endResetModel();
+    Q_EMIT rowCountChanged();
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/ArtistsModel.hh'
--- src/qml/Ubuntu/MediaScanner/ArtistsModel.hh	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/ArtistsModel.hh	2014-05-29 09:17:39 +0000
@@ -24,6 +24,7 @@
 #include <QAbstractListModel>
 #include <QString>
 
+#include <mediascanner/Filter.hh>
 #include "MediaStoreWrapper.hh"
 
 namespace mediascanner {
@@ -34,8 +35,9 @@
     Q_ENUMS(Roles)
     Q_PROPERTY(mediascanner::qml::MediaStoreWrapper* store READ getStore WRITE setStore)
     Q_PROPERTY(bool albumArtists READ getAlbumArtists WRITE setAlbumArtists)
+    Q_PROPERTY(QVariant genre READ getGenre WRITE setGenre)
     Q_PROPERTY(int limit READ getLimit WRITE setLimit)
-    Q_PROPERTY(int rowCount READ rowCount) // NOTIFY modelReset
+    Q_PROPERTY(int rowCount READ rowCount NOTIFY rowCountChanged)
 public:
     enum Roles {
         RoleArtist,
@@ -46,6 +48,8 @@
     QVariant data(const QModelIndex &index, int role) const override;
 
     Q_INVOKABLE QVariant get(int row, Roles role) const;
+Q_SIGNALS:
+    void rowCountChanged();
 protected:
     QHash<int, QByteArray> roleNames() const override;
 
@@ -53,6 +57,8 @@
     void setStore(MediaStoreWrapper *store);
     bool getAlbumArtists();
     void setAlbumArtists(bool album_artists);
+    QVariant getGenre();
+    void setGenre(QVariant genre);
     int getLimit();
     void setLimit(int limit);
 
@@ -62,6 +68,7 @@
     QHash<int, QByteArray> roles;
     std::vector<std::string> results;
     MediaStoreWrapper *store;
+    Filter filter;
     bool album_artists;
     int limit;
 };

=== modified file 'src/qml/Ubuntu/MediaScanner/CMakeLists.txt'
--- src/qml/Ubuntu/MediaScanner/CMakeLists.txt	2014-05-29 09:17:39 +0000
+++ src/qml/Ubuntu/MediaScanner/CMakeLists.txt	2014-05-29 09:17:39 +0000
@@ -12,6 +12,7 @@
   AlbumModelBase.cc
   AlbumsModel.cc
   ArtistsModel.cc
+  GenresModel.cc
   SongsModel.cc
   SongsSearchModel.cc
 )

=== added file 'src/qml/Ubuntu/MediaScanner/GenresModel.cc'
--- src/qml/Ubuntu/MediaScanner/GenresModel.cc	1970-01-01 00:00:00 +0000
+++ src/qml/Ubuntu/MediaScanner/GenresModel.cc	2014-05-29 09:17:39 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "GenresModel.hh"
+
+using namespace mediascanner::qml;
+
+GenresModel::GenresModel(QObject *parent)
+    : QAbstractListModel(parent),
+      store(nullptr),
+      limit(-1) {
+    roles[Roles::RoleGenre] = "genre";
+}
+
+int GenresModel::rowCount(const QModelIndex &) const {
+    return results.size();
+}
+
+QVariant GenresModel::data(const QModelIndex &index, int role) const {
+    if (index.row() < 0 || index.row() >= (ptrdiff_t)results.size()) {
+        return QVariant();
+    }
+    switch (role) {
+    case RoleGenre:
+        return QString::fromStdString(results[index.row()]);
+    default:
+        return QVariant();
+    }
+}
+
+QVariant GenresModel::get(int row, GenresModel::Roles role) const {
+    return data(index(row, 0), role);
+}
+
+QHash<int, QByteArray> GenresModel::roleNames() const {
+    return roles;
+}
+
+MediaStoreWrapper *GenresModel::getStore() {
+    return store;
+}
+
+void GenresModel::setStore(MediaStoreWrapper *store) {
+    if (this->store != store) {
+        this->store = store;
+        update();
+    }
+}
+
+int GenresModel::getLimit() {
+    return limit;
+}
+
+void GenresModel::setLimit(int limit) {
+    if (this->limit != limit) {
+        this->limit = limit;
+        update();
+    }
+}
+
+void GenresModel::update() {
+    beginResetModel();
+    if (store == nullptr) {
+        this->results.clear();
+    } else {
+        this->results = store->store.listGenres(limit);
+    }
+    endResetModel();
+    Q_EMIT rowCountChanged();
+}

=== added file 'src/qml/Ubuntu/MediaScanner/GenresModel.hh'
--- src/qml/Ubuntu/MediaScanner/GenresModel.hh	1970-01-01 00:00:00 +0000
+++ src/qml/Ubuntu/MediaScanner/GenresModel.hh	2014-05-29 09:17:39 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *    James Henstridge <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MEDIASCANNER_QML_GENRESMODEL_H
+#define MEDIASCANNER_QML_GENRESMODEL_H
+
+#include <string>
+#include <QAbstractListModel>
+#include <QString>
+
+#include <mediascanner/Filter.hh>
+#include "MediaStoreWrapper.hh"
+
+namespace mediascanner {
+namespace qml {
+
+class GenresModel : public QAbstractListModel {
+    Q_OBJECT
+    Q_ENUMS(Roles)
+    Q_PROPERTY(mediascanner::qml::MediaStoreWrapper* store READ getStore WRITE setStore)
+    Q_PROPERTY(int limit READ getLimit WRITE setLimit)
+    Q_PROPERTY(int rowCount READ rowCount NOTIFY rowCountChanged)
+public:
+    enum Roles {
+        RoleGenre,
+    };
+
+    explicit GenresModel(QObject *parent = 0);
+    int rowCount(const QModelIndex &parent=QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+
+    Q_INVOKABLE QVariant get(int row, Roles role) const;
+Q_SIGNALS:
+    void rowCountChanged();
+protected:
+    QHash<int, QByteArray> roleNames() const override;
+
+    MediaStoreWrapper *getStore();
+    void setStore(MediaStoreWrapper *store);
+    int getLimit();
+    void setLimit(int limit);
+
+private:
+    void update();
+
+    QHash<int, QByteArray> roles;
+    std::vector<std::string> results;
+    MediaStoreWrapper *store;
+    int limit;
+};
+
+}
+}
+
+#endif

=== modified file 'src/qml/Ubuntu/MediaScanner/MediaFileModelBase.cc'
--- src/qml/Ubuntu/MediaScanner/MediaFileModelBase.cc	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/MediaFileModelBase.cc	2014-05-29 09:17:39 +0000
@@ -99,4 +99,5 @@
     beginResetModel();
     this->results = results;
     endResetModel();
+    Q_EMIT rowCountChanged();
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/MediaFileModelBase.hh'
--- src/qml/Ubuntu/MediaScanner/MediaFileModelBase.hh	2014-05-06 09:09:49 +0000
+++ src/qml/Ubuntu/MediaScanner/MediaFileModelBase.hh	2014-05-29 09:17:39 +0000
@@ -31,7 +31,7 @@
 class MediaFileModelBase : public QAbstractListModel {
     Q_OBJECT
     Q_ENUMS(Roles)
-    Q_PROPERTY(int rowCount READ rowCount) // NOTIFY modelReset
+    Q_PROPERTY(int rowCount READ rowCount NOTIFY rowCountChanged)
 public:
     enum Roles {
         RoleModelData,
@@ -56,6 +56,8 @@
     QVariant data(const QModelIndex &index, int role) const override;
 
     Q_INVOKABLE QVariant get(int row, Roles role) const;
+Q_SIGNALS:
+    void rowCountChanged();
 protected:
     QHash<int, QByteArray> roleNames() const override;
     void updateResults(const std::vector<mediascanner::MediaFile> &results);

=== modified file 'src/qml/Ubuntu/MediaScanner/SongsModel.cc'
--- src/qml/Ubuntu/MediaScanner/SongsModel.cc	2014-02-27 05:37:36 +0000
+++ src/qml/Ubuntu/MediaScanner/SongsModel.cc	2014-05-29 09:17:39 +0000
@@ -24,9 +24,6 @@
 SongsModel::SongsModel(QObject *parent)
     : MediaFileModelBase(parent),
       store(nullptr),
-      artist(""),
-      album(""),
-      album_artist(""),
       limit(-1) {
 }
 
@@ -41,36 +38,87 @@
     }
 }
 
-QString SongsModel::getArtist() {
-    return artist;
-}
-
-void SongsModel::setArtist(const QString artist) {
-    if (this->artist != artist) {
-        this->artist = artist;
-        update();
-    }
-}
-
-QString SongsModel::getAlbum() {
-    return album;
-}
-
-void SongsModel::setAlbum(const QString album) {
-    if (this->album != album) {
-        this->album = album;
-        update();
-    }
-}
-
-QString SongsModel::getAlbumArtist() {
-    return album_artist;
-}
-
-void SongsModel::setAlbumArtist(const QString album_artist) {
-    if (this->album_artist != album_artist) {
-        this->album_artist = album_artist;
-        update();
+QVariant SongsModel::getArtist() {
+    if (!filter.hasArtist())
+        return QVariant();
+    return QString::fromStdString(filter.getArtist());
+}
+
+void SongsModel::setArtist(const QVariant artist) {
+    if (artist.isNull()) {
+        if (filter.hasArtist()) {
+            filter.unsetArtist();
+            update();
+        }
+    } else {
+        const std::string std_artist = artist.value<QString>().toStdString();
+        if (!filter.hasArtist() || filter.getArtist() != std_artist) {
+            filter.setArtist(std_artist);
+            update();
+        }
+    }
+}
+
+QVariant SongsModel::getAlbum() {
+    if (!filter.hasAlbum())
+        return QVariant();
+    return QString::fromStdString(filter.getAlbum());
+}
+
+void SongsModel::setAlbum(const QVariant album) {
+    if (album.isNull()) {
+        if (filter.hasAlbum()) {
+            filter.unsetAlbum();
+            update();
+        }
+    } else {
+        const std::string std_album = album.value<QString>().toStdString();
+        if (!filter.hasAlbum() || filter.getAlbum() != std_album) {
+            filter.setAlbum(std_album);
+            update();
+        }
+    }
+}
+
+QVariant SongsModel::getAlbumArtist() {
+    if (!filter.hasAlbumArtist())
+        return QVariant();
+    return QString::fromStdString(filter.getAlbumArtist());
+}
+
+void SongsModel::setAlbumArtist(const QVariant album_artist) {
+    if (album_artist.isNull()) {
+        if (filter.hasAlbumArtist()) {
+            filter.unsetAlbumArtist();
+            update();
+        }
+    } else {
+        const std::string std_album_artist = album_artist.value<QString>().toStdString();
+        if (!filter.hasAlbumArtist() || filter.getAlbumArtist() != std_album_artist) {
+            filter.setAlbumArtist(std_album_artist);
+            update();
+        }
+    }
+}
+
+QVariant SongsModel::getGenre() {
+    if (!filter.hasGenre())
+        return QVariant();
+    return QString::fromStdString(filter.getGenre());
+}
+
+void SongsModel::setGenre(const QVariant genre) {
+    if (genre.isNull()) {
+        if (filter.hasGenre()) {
+            filter.unsetGenre();
+            update();
+        }
+    } else {
+        const std::string std_genre = genre.value<QString>().toStdString();
+        if (!filter.hasGenre() || filter.getGenre() != std_genre) {
+            filter.setGenre(std_genre);
+            update();
+        }
     }
 }
 
@@ -89,6 +137,6 @@
     if (store == nullptr) {
         updateResults(std::vector<mediascanner::MediaFile>());
     } else {
-        updateResults(store->store.listSongs(artist.toStdString(), album.toStdString(), album_artist.toStdString(), limit));
+        updateResults(store->store.listSongs(filter, limit));
     }
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/SongsModel.hh'
--- src/qml/Ubuntu/MediaScanner/SongsModel.hh	2014-02-27 05:37:36 +0000
+++ src/qml/Ubuntu/MediaScanner/SongsModel.hh	2014-05-29 09:17:39 +0000
@@ -22,6 +22,7 @@
 
 #include <QString>
 
+#include <mediascanner/Filter.hh>
 #include "MediaStoreWrapper.hh"
 #include "MediaFileModelBase.hh"
 
@@ -31,9 +32,10 @@
 class SongsModel : public MediaFileModelBase {
     Q_OBJECT
     Q_PROPERTY(mediascanner::qml::MediaStoreWrapper* store READ getStore WRITE setStore)
-    Q_PROPERTY(QString artist READ getArtist WRITE setArtist)
-    Q_PROPERTY(QString album READ getAlbum WRITE setAlbum)
-    Q_PROPERTY(QString albumArtist READ getAlbumArtist WRITE setAlbumArtist)
+    Q_PROPERTY(QVariant artist READ getArtist WRITE setArtist)
+    Q_PROPERTY(QVariant album READ getAlbum WRITE setAlbum)
+    Q_PROPERTY(QVariant albumArtist READ getAlbumArtist WRITE setAlbumArtist)
+    Q_PROPERTY(QVariant genre READ getGenre WRITE setGenre)
     Q_PROPERTY(int limit READ getLimit WRITE setLimit)
 public:
     explicit SongsModel(QObject *parent=0);
@@ -41,19 +43,21 @@
     MediaStoreWrapper *getStore();
     void setStore(MediaStoreWrapper *store);
 
-    QString getArtist();
-    void setArtist(const QString artist);
-    QString getAlbum();
-    void setAlbum(const QString album);
-    QString getAlbumArtist();
-    void setAlbumArtist(const QString album_artist);
+    QVariant getArtist();
+    void setArtist(const QVariant artist);
+    QVariant getAlbum();
+    void setAlbum(const QVariant album);
+    QVariant getAlbumArtist();
+    void setAlbumArtist(const QVariant album_artist);
+    QVariant getGenre();
+    void setGenre(const QVariant genre);
     int getLimit();
     void setLimit(int limit);
 private:
     void update();
 
     MediaStoreWrapper *store;
-    QString artist, album, album_artist;
+    Filter filter;
     int limit;
 };
 

=== modified file 'src/qml/Ubuntu/MediaScanner/plugin.cc'
--- src/qml/Ubuntu/MediaScanner/plugin.cc	2014-02-28 07:01:44 +0000
+++ src/qml/Ubuntu/MediaScanner/plugin.cc	2014-05-29 09:17:39 +0000
@@ -22,6 +22,7 @@
 #include "MediaStoreWrapper.hh"
 #include "AlbumsModel.hh"
 #include "ArtistsModel.hh"
+#include "GenresModel.hh"
 #include "SongsModel.hh"
 #include "SongsSearchModel.hh"
 
@@ -33,6 +34,7 @@
         "Use a MediaStore to retrieve MediaFiles");
     qmlRegisterType<AlbumsModel>(uri, 0, 1, "AlbumsModel");
     qmlRegisterType<ArtistsModel>(uri, 0, 1, "ArtistsModel");
+    qmlRegisterType<GenresModel>(uri, 0, 1, "GenresModel");
     qmlRegisterType<SongsModel>(uri, 0, 1, "SongsModel");
     qmlRegisterType<SongsSearchModel>(uri, 0, 1, "SongsSearchModel");
 }

=== modified file 'src/qml/Ubuntu/MediaScanner/plugin.qmltypes'
--- src/qml/Ubuntu/MediaScanner/plugin.qmltypes	2014-05-08 07:17:11 +0000
+++ src/qml/Ubuntu/MediaScanner/plugin.qmltypes	2014-05-29 09:17:39 +0000
@@ -32,8 +32,9 @@
         exports: ["Ubuntu.MediaScanner/AlbumsModel 0.1"]
         exportMetaObjectRevisions: [0]
         Property { name: "store"; type: "mediascanner::qml::MediaStoreWrapper"; isPointer: true }
-        Property { name: "artist"; type: "string" }
-        Property { name: "albumArtist"; type: "string" }
+        Property { name: "artist"; type: "QVariant" }
+        Property { name: "albumArtist"; type: "QVariant" }
+        Property { name: "genre"; type: "QVariant" }
         Property { name: "limit"; type: "int" }
     }
     Component {
@@ -49,6 +50,28 @@
         }
         Property { name: "store"; type: "mediascanner::qml::MediaStoreWrapper"; isPointer: true }
         Property { name: "albumArtists"; type: "bool" }
+        Property { name: "genre"; type: "QVariant" }
+        Property { name: "limit"; type: "int" }
+        Property { name: "rowCount"; type: "int"; isReadonly: true }
+        Method {
+            name: "get"
+            type: "QVariant"
+            Parameter { name: "row"; type: "int" }
+            Parameter { name: "role"; type: "Roles" }
+        }
+    }
+    Component {
+        name: "mediascanner::qml::GenresModel"
+        prototype: "QAbstractListModel"
+        exports: ["Ubuntu.MediaScanner/GenresModel 0.1"]
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "Roles"
+            values: {
+                "RoleGenre": 0
+            }
+        }
+        Property { name: "store"; type: "mediascanner::qml::MediaStoreWrapper"; isPointer: true }
         Property { name: "limit"; type: "int" }
         Property { name: "rowCount"; type: "int"; isReadonly: true }
         Method {
@@ -140,9 +163,10 @@
         exports: ["Ubuntu.MediaScanner/SongsModel 0.1"]
         exportMetaObjectRevisions: [0]
         Property { name: "store"; type: "mediascanner::qml::MediaStoreWrapper"; isPointer: true }
-        Property { name: "artist"; type: "string" }
-        Property { name: "album"; type: "string" }
-        Property { name: "albumArtist"; type: "string" }
+        Property { name: "artist"; type: "QVariant" }
+        Property { name: "album"; type: "QVariant" }
+        Property { name: "albumArtist"; type: "QVariant" }
+        Property { name: "genre"; type: "QVariant" }
         Property { name: "limit"; type: "int" }
     }
     Component {

=== modified file 'src/qml/Ubuntu/MediaScanner/qmldir'
--- src/qml/Ubuntu/MediaScanner/qmldir	2014-01-02 07:48:47 +0000
+++ src/qml/Ubuntu/MediaScanner/qmldir	2014-05-29 09:17:39 +0000
@@ -1,2 +1,3 @@
 module Ubuntu.MediaScanner
 plugin mediascanner-qml
+typeinfo plugin.qmltypes

=== added file 'test/qml/tst_albumsmodel.qml'
--- test/qml/tst_albumsmodel.qml	1970-01-01 00:00:00 +0000
+++ test/qml/tst_albumsmodel.qml	2014-05-29 09:17:39 +0000
@@ -0,0 +1,91 @@
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.MediaScanner 0.1
+
+Item {
+    id: root
+
+    MediaStore {
+        id: store
+    }
+
+    AlbumsModel {
+        id: model
+        store: store
+    }
+
+    TestCase {
+        name: "AlbumsModelTests"
+
+        function cleanup() {
+            model.artist = undefined;
+            model.albumArtist = undefined;
+            model.genre = undefined;
+            model.limit = -1;
+        }
+
+        function test_initial_state() {
+            compare(model.artist, undefined);
+            compare(model.albumArtist, undefined);
+            compare(model.genre, undefined);
+            compare(model.limit, -1);
+
+            compare(model.rowCount, 4);
+            compare(model.get(0, AlbumsModel.RoleTitle), "Ivy and the Big Apples");
+            compare(model.get(0, AlbumsModel.RoleArtist), "Spiderbait");
+
+            compare(model.get(1, AlbumsModel.RoleTitle), "Spiderbait");
+            compare(model.get(1, AlbumsModel.RoleArtist), "Spiderbait");
+
+            compare(model.get(2, AlbumsModel.RoleTitle), "April Uprising");
+            compare(model.get(2, AlbumsModel.RoleArtist), "The John Butler Trio");
+
+            compare(model.get(3, AlbumsModel.RoleTitle), "Sunrise Over Sea");
+            compare(model.get(3, AlbumsModel.RoleArtist), "The John Butler Trio");
+        }
+
+        function test_limit() {
+            model.limit = 2;
+            compare(model.rowCount, 2);
+
+            model.limit = 42;
+            compare(model.rowCount, 4);
+
+            model.limit = -1;
+            compare(model.rowCount, 4);
+        }
+
+        function test_artist() {
+            model.artist = "The John Butler Trio";
+            compare(model.rowCount, 2);
+
+            compare(model.get(0, AlbumsModel.RoleTitle), "April Uprising");
+            compare(model.get(0, AlbumsModel.RoleArtist), "The John Butler Trio");
+
+            model.artist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+        function test_album_artist() {
+            model.albumArtist = "The John Butler Trio";
+            compare(model.rowCount, 2);
+
+            compare(model.get(0, AlbumsModel.RoleTitle), "April Uprising");
+            compare(model.get(0, AlbumsModel.RoleArtist), "The John Butler Trio");
+
+            model.albumArtist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+        function test_genre() {
+            model.genre = "rock";
+            compare(model.rowCount, 2);
+            compare(model.get(0, AlbumsModel.RoleTitle), "Ivy and the Big Apples");
+            compare(model.get(1, AlbumsModel.RoleTitle), "Spiderbait");
+
+            model.genre = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+    }
+}

=== added file 'test/qml/tst_artistsmodel.qml'
--- test/qml/tst_artistsmodel.qml	1970-01-01 00:00:00 +0000
+++ test/qml/tst_artistsmodel.qml	2014-05-29 09:17:39 +0000
@@ -0,0 +1,68 @@
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.MediaScanner 0.1
+
+Item {
+    id: root
+
+    MediaStore {
+        id: store
+    }
+
+    ArtistsModel {
+        id: model
+        store: store
+    }
+
+    TestCase {
+        name: "ArtistsModelTests"
+
+        function cleanup() {
+            model.albumArtists = false;
+            model.genre = undefined;
+            model.limit = -1;
+        }
+
+        function test_initial_state() {
+            compare(model.albumArtists, false);
+            compare(model.limit, -1);
+
+            compare(model.rowCount, 2);
+            compare(model.get(0, ArtistsModel.RoleArtist), "Spiderbait");
+            compare(model.get(1, ArtistsModel.RoleArtist), "The John Butler Trio");
+        }
+
+        function test_limit() {
+            model.limit = 1;
+            compare(model.rowCount, 1);
+
+            model.limit = 42;
+            compare(model.rowCount, 2);
+
+            model.limit = -1;
+            compare(model.rowCount, 2);
+        }
+
+        function test_album_artists() {
+            model.albumArtists = true;
+            compare(model.rowCount, 2);
+
+            compare(model.get(0, ArtistsModel.RoleArtist), "Spiderbait");
+            compare(model.get(1, ArtistsModel.RoleArtist), "The John Butler Trio");
+        }
+
+        function test_genre() {
+            model.genre = "rock";
+            compare(model.rowCount, 1);
+            compare(model.get(0, ArtistsModel.RoleArtist), "Spiderbait");
+
+            model.genre = "roots";
+            compare(model.rowCount, 1);
+            compare(model.get(0, ArtistsModel.RoleArtist), "The John Butler Trio");
+
+            model.genre = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+    }
+}

=== added file 'test/qml/tst_genresmodel.qml'
--- test/qml/tst_genresmodel.qml	1970-01-01 00:00:00 +0000
+++ test/qml/tst_genresmodel.qml	2014-05-29 09:17:39 +0000
@@ -0,0 +1,44 @@
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.MediaScanner 0.1
+
+Item {
+    id: root
+
+    MediaStore {
+        id: store
+    }
+
+    GenresModel {
+        id: model
+        store: store
+    }
+
+    TestCase {
+        name: "GenresModelTests"
+
+        function cleanup() {
+            model.limit = -1;
+        }
+
+        function test_initial_state() {
+            compare(model.limit, -1);
+
+            compare(model.rowCount, 2);
+            compare(model.get(0, ArtistsModel.RoleGenre), "rock");
+            compare(model.get(1, ArtistsModel.RoleGenre), "roots");
+        }
+
+        function test_limit() {
+            model.limit = 1;
+            compare(model.rowCount, 1);
+
+            model.limit = 42;
+            compare(model.rowCount, 2);
+
+            model.limit = -1;
+            compare(model.rowCount, 2);
+        }
+
+    }
+}

=== added file 'test/qml/tst_songsmodel.qml'
--- test/qml/tst_songsmodel.qml	1970-01-01 00:00:00 +0000
+++ test/qml/tst_songsmodel.qml	2014-05-29 09:17:39 +0000
@@ -0,0 +1,104 @@
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.MediaScanner 0.1
+
+Item {
+    id: root
+
+    MediaStore {
+        id: store
+    }
+
+    SongsModel {
+        id: model
+        store: store
+    }
+
+    TestCase {
+        name: "SongsModelTests"
+
+        function cleanup() {
+            model.artist = undefined;
+            model.albumArtist = undefined;
+            model.album = undefined;
+            model.genre = undefined;
+            model.limit = -1;
+        }
+
+        function test_initial_state() {
+            compare(model.artist, undefined);
+            compare(model.albumArtist, undefined);
+            compare(model.album, undefined);
+            compare(model.limit, -1);
+
+            compare(model.rowCount, 7);
+            compare(model.get(0, SongsModel.RoleTitle), "Buy Me a Pony")
+            compare(model.get(0, SongsModel.RoleAlbum), "Ivy and the Big Apples");
+            compare(model.get(0, SongsModel.RoleAuthor), "Spiderbait");
+
+            compare(model.get(1, SongsModel.RoleTitle), "Straight Through The Sun");
+            compare(model.get(2, SongsModel.RoleTitle), "It's Beautiful");
+            compare(model.get(3, SongsModel.RoleTitle), "Revolution");
+            compare(model.get(4, SongsModel.RoleTitle), "One Way Road");
+            compare(model.get(5, SongsModel.RoleTitle), "Peaches & Cream");
+            compare(model.get(6, SongsModel.RoleTitle), "Zebra");
+        }
+
+        function test_limit() {
+            model.limit = 2;
+            compare(model.rowCount, 2);
+
+            model.limit = 42;
+            compare(model.rowCount, 7);
+
+            model.limit = -1;
+            compare(model.rowCount, 7);
+        }
+
+        function test_artist() {
+            model.artist = "The John Butler Trio";
+            compare(model.rowCount, 4);
+
+            compare(model.get(0, SongsModel.RoleTitle), "Revolution");
+            compare(model.get(0, SongsModel.RoleAuthor), "The John Butler Trio");
+
+            model.artist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+        function test_album_artist() {
+            model.albumArtist = "The John Butler Trio";
+            compare(model.rowCount, 4);
+
+            compare(model.get(0, SongsModel.RoleTitle), "Revolution");
+            compare(model.get(0, SongsModel.RoleAuthor), "The John Butler Trio");
+
+            model.albumArtist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+        function test_album() {
+            model.album = "Sunrise Over Sea";
+            compare(model.rowCount, 2);
+
+            compare(model.get(0, SongsModel.RoleTitle), "Peaches & Cream");
+            compare(model.get(0, SongsModel.RoleAuthor), "The John Butler Trio");
+
+            model.albumArtist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+        function test_genre() {
+            model.genre = "rock";
+            compare(model.rowCount, 3);
+
+            compare(model.get(0, SongsModel.RoleTitle), "Buy Me a Pony");
+            compare(model.get(1, SongsModel.RoleTitle), "Straight Through The Sun");
+            compare(model.get(2, SongsModel.RoleTitle), "It's Beautiful");
+
+            model.albumArtist = "unknown";
+            compare(model.rowCount, 0);
+        }
+
+    }
+}

=== modified file 'test/test_dbus.cc'
--- test/test_dbus.cc	2014-05-29 09:17:39 +0000
+++ test/test_dbus.cc	2014-05-29 09:17:39 +0000
@@ -6,18 +6,24 @@
 #include <mediascanner/Album.hh>
 #include <mediascanner/MediaFile.hh>
 #include <mediascanner/MediaFileBuilder.hh>
+#include <mediascanner/Filter.hh>
 #include <ms-dbus/dbus-codec.hh>
 
 class MediaStoreDBusTests : public ::testing::Test {
+protected:
+    virtual void SetUp() override {
+        ::testing::Test::SetUp();
+        message = core::dbus::Message::make_method_call(
+            "org.example.Name",
+            core::dbus::types::ObjectPath("/org/example/Path"),
+            "org.example.Interface",
+            "Method");
+    }
+
+    core::dbus::Message::Ptr message;
 };
 
 TEST_F(MediaStoreDBusTests, mediafile_codec) {
-    auto message = core::dbus::Message::make_method_call(
-        "org.example.Name",
-        core::dbus::types::ObjectPath("/org/example/Path"),
-        "org.example.Interface",
-        "Method");
-
     mediascanner::MediaFile media = mediascanner::MediaFileBuilder("a")
         .setContentType("type")
         .setETag("etag")
@@ -42,12 +48,6 @@
 }
 
 TEST_F(MediaStoreDBusTests, album_codec) {
-    auto message = core::dbus::Message::make_method_call(
-        "org.example.Name",
-        core::dbus::types::ObjectPath("/org/example/Path"),
-        "org.example.Interface",
-        "Method");
-
     mediascanner::Album album("title", "artist");
     message->writer() << album;
 
@@ -61,6 +61,33 @@
     EXPECT_EQ(album, album2);
 }
 
+TEST_F(MediaStoreDBusTests, filter_codec) {
+    mediascanner::Filter filter;
+    filter.setArtist("Artist1");
+    filter.setAlbum("Album1");
+    filter.setAlbumArtist("AlbumArtist1");
+    filter.setGenre("Genre");
+    message->writer() << filter;
+
+    EXPECT_EQ("a{ss}", message->signature());
+    EXPECT_EQ(core::dbus::helper::TypeMapper<mediascanner::Filter>::signature(), message->signature());
+
+    mediascanner::Filter other;
+    message->reader() >> other;
+    EXPECT_EQ(filter, other);
+}
+
+TEST_F(MediaStoreDBusTests, filter_codec_empty) {
+    mediascanner::Filter empty;
+    message->writer() << empty;
+
+    EXPECT_EQ("a{ss}", message->signature());
+
+    mediascanner::Filter other;
+    message->reader() >> other;
+    EXPECT_EQ(empty, other);
+}
+
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();

=== modified file 'test/test_mediastore.cc'
--- test/test_mediastore.cc	2014-05-29 09:17:39 +0000
+++ test/test_mediastore.cc	2014-05-29 09:17:39 +0000
@@ -20,6 +20,7 @@
 #include <mediascanner/MediaFile.hh>
 #include <mediascanner/MediaFileBuilder.hh>
 #include <mediascanner/Album.hh>
+#include <mediascanner/Filter.hh>
 #include <mediascanner/MediaStore.hh>
 #include <mediascanner/internal/utils.hh>
 
@@ -617,34 +618,56 @@
     store.insert(audio5);
     store.insert(audio6);
 
-    vector<MediaFile> tracks = store.listSongs();
+    Filter filter;
+    vector<MediaFile> tracks = store.listSongs(filter);
     ASSERT_EQ(6, tracks.size());
     EXPECT_EQ("TitleOne", tracks[0].getTitle());
 
     // Apply a limit
-    tracks = store.listSongs("", "", "", 4);
+    tracks = store.listSongs(filter, 4);
     EXPECT_EQ(4, tracks.size());
 
     // List songs by artist
-    tracks = store.listSongs("ArtistOne");
+    filter.setArtist("ArtistOne");
+    tracks = store.listSongs(filter);
     EXPECT_EQ(4, tracks.size());
 
     // List songs by album
-    tracks = store.listSongs("", "AlbumOne");
+    filter.clear();
+    filter.setAlbum("AlbumOne");
+    tracks = store.listSongs(filter);
     EXPECT_EQ(2, tracks.size());
 
     // List songs by album artist
-    tracks = store.listSongs("", "", "Various Artists");
+    filter.clear();
+    filter.setAlbumArtist("Various Artists");
+    tracks = store.listSongs(filter);
     EXPECT_EQ(2, tracks.size());
 
     // Combinations
-    tracks = store.listSongs("ArtistOne", "AlbumOne", "");
-    EXPECT_EQ(2, tracks.size());
-    tracks = store.listSongs("", "AlbumOne", "ArtistOne");
-    EXPECT_EQ(2, tracks.size());
-    tracks = store.listSongs("ArtistOne", "AlbumOne", "ArtistOne");
-    EXPECT_EQ(2, tracks.size());
-    tracks = store.listSongs("ArtistOne", "", "ArtistOne");
+    filter.clear();
+    filter.setArtist("ArtistOne");
+    filter.setAlbum("AlbumOne");
+    tracks = store.listSongs(filter);
+    EXPECT_EQ(2, tracks.size());
+
+    filter.clear();
+    filter.setAlbum("AlbumOne");
+    filter.setAlbumArtist("ArtistOne");
+    tracks = store.listSongs(filter);
+    EXPECT_EQ(2, tracks.size());
+
+    filter.clear();
+    filter.setArtist("ArtistOne");
+    filter.setAlbum("AlbumOne");
+    filter.setAlbumArtist("ArtistOne");
+    tracks = store.listSongs(filter);
+    EXPECT_EQ(2, tracks.size());
+
+    filter.clear();
+    filter.setArtist("ArtistOne");
+    filter.setAlbumArtist("ArtistOne");
+    tracks = store.listSongs(filter);
     EXPECT_EQ(3, tracks.size());
 }
 
@@ -687,24 +710,31 @@
     store.insert(audio4);
     store.insert(audio5);
 
-    vector<Album> albums = store.listAlbums();
+    Filter filter;
+    vector<Album> albums = store.listAlbums(filter);
     ASSERT_EQ(4, albums.size());
     EXPECT_EQ("AlbumOne", albums[0].getTitle());
 
     // test limit
-    albums = store.listAlbums("", "", 2);
+    albums = store.listAlbums(filter, 2);
     EXPECT_EQ(2, albums.size());
 
     // Songs by artist
-    albums = store.listAlbums("ArtistOne");
+    filter.setArtist("ArtistOne");
+    albums = store.listAlbums(filter);
     EXPECT_EQ(3, albums.size());
 
     // Songs by album artist
-    albums = store.listAlbums("", "ArtistOne");
+    filter.clear();
+    filter.setAlbumArtist("ArtistOne");
+    albums = store.listAlbums(filter);
     EXPECT_EQ(2, albums.size());
 
     // Combination
-    albums = store.listAlbums("ArtistOne", "Various Artists");
+    filter.clear();
+    filter.setArtist("ArtistOne");
+    filter.setAlbumArtist("Various Artists");
+    albums = store.listAlbums(filter);
     EXPECT_EQ(1, albums.size());
 }
 
@@ -747,17 +777,18 @@
     store.insert(audio4);
     store.insert(audio5);
 
-    vector<string> artists = store.listArtists(false);
+    Filter filter;
+    vector<string> artists = store.listArtists(filter);
     ASSERT_EQ(2, artists.size());
     EXPECT_EQ("ArtistOne", artists[0]);
     EXPECT_EQ("ArtistTwo", artists[1]);
 
     // Test limit clause
-    artists = store.listArtists(false, 1);
+    artists = store.listArtists(filter, 1);
     EXPECT_EQ(1, artists.size());
 
     // List "album artists"
-    artists = store.listArtists(true);
+    artists = store.listAlbumArtists(filter);
     ASSERT_EQ(3, artists.size());
     EXPECT_EQ("ArtistOne", artists[0]);
     EXPECT_EQ("ArtistTwo", artists[1]);