Merge lp:~jamesh/mediascanner2/dbus-transport into lp:mediascanner2

[James Henstridge]

Add a D-Bus service exposing the MediaStore, and move the QML binding over to using it.

Add a D-Bus service exposing the MediaStore, and move the QML binding over to using it.

Eventually the libmediascanner MediaStore API should be going through this API, but I decided to move the QML binding over first before refactoring the core.

The impetus for this change is to allow for more fine grained control of access to the index from confined applications (which is also to come).

The no-argument MediaFile and Album constructors were necessary to work with libdbus-cpp's templates.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:251
http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/73/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-armhf-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-i386-ci/14/console

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

review: Needs Fixing (continuous-integration)

[lp:~jamesh/mediascanner2/dbus-transport]

252. By James Henstridge on 2014-05-23

Build-Depend on libdbus-1-dev.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:252
http://jenkins.qa.ubuntu.com/job/mediascanner2-ci/74/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-amd64-ci/15/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-armhf-ci/15/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mediascanner2-utopic-i386-ci/15/console

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

review: Needs Fixing (continuous-integration)

[lp:~jamesh/mediascanner2/dbus-transport]

253. By James Henstridge on 2014-05-23

Build-Depend on libproperties-cpp-dev.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Jussi Pakkanen (jpakkane)]

Looking good. All the dbus stuff is nicely isolated in its own thing away from the core. There are a few issues, though, but they are more fundamental than actual code problems.

> +set_target_properties(ms-dbus PROPERTIES COMPILE_FLAGS "-fPIC")

I assume this is because this library is used as part of the qml module? If yes, please add a comment above this line saying so.

> The no-argument MediaFile and Album constructors were necessary to work with
> libdbus-cpp's templates.

This is bad. It destroys the security we worked so hard to build into Mediafiles, namely that it is very hard to construct an invalid one. I would classify this as a bug in dbus-cpp, an RPC library should not place these sorts of requirements on the classes it handles. Could you file a bug on dbus-cpp about this with all the necessary information?

I'm also worried about the mixed technologies here. We are already dealing with quite a lot of Qt stuff and instead of using Qt's dbus system we use a different one. But since that ship has already sailed, let's go with this. We can always change it later thanks to the proper isolation of dbus from the core.

review: Needs Fixing

[lp:~jamesh/mediascanner2/dbus-transport]

254. By James Henstridge on 2014-05-23

Add a comment explaining why the helper D-Bus library is linked with -fPIC.

[James Henstridge (jamesh)]

I've added a comment to the make file.

I've filed a bug report here:

https://bugs.launchpad.net/dbus-cpp/+bug/1322611

For reference, here is the class that required the default constructors:

http://bazaar.launchpad.net/~phablet-team/dbus-cpp/trunk/view/head:/include/core/dbus/result.h#L36

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[lp:~jamesh/mediascanner2/dbus-transport]

255. By James Henstridge on 2014-05-24

Remove some excess debug logging.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-03-28 03:43:17 +0000
+++ CMakeLists.txt	2014-05-24 09:41:18 +0000
@@ -15,6 +15,7 @@
   sqlite3
 )
 pkg_check_modules(GST gstreamer-1.0 gstreamer-pbutils-1.0 REQUIRED)
+pkg_check_modules(DBUSCPP dbus-cpp REQUIRED)
 find_package(Threads REQUIRED)
 find_package(Qt5Core REQUIRED)
 
@@ -32,6 +33,7 @@
 
 add_subdirectory(src/mediascanner)
 add_subdirectory(src/daemon)
+add_subdirectory(src/ms-dbus)
 add_subdirectory(src/qml/Ubuntu/MediaScanner)
 add_subdirectory(src/utils)
 add_subdirectory(test)

=== modified file 'debian/control'
--- debian/control	2014-03-28 03:43:17 +0000
+++ debian/control	2014-05-24 09:41:18 +0000
@@ -4,11 +4,15 @@
 Maintainer: Ubuntu Core Developers <[e-mail]>
 Standards-Version: 3.9.5
 Build-Depends: cmake,
+               dbus,
                debhelper (>= 9),
+               libdbus-1-dev,
+               libdbus-cpp-dev (>= 3.0.0),
                libglib2.0-dev,
                libgstreamer-plugins-base1.0-dev,
                libgstreamer1.0-dev,
                libgtest-dev,
+               libproperties-cpp-dev,
                libsqlite3-dev,
                qt5-default,
                qtbase5-dev,

=== modified file 'debian/mediascanner2.0.install'
--- debian/mediascanner2.0.install	2013-12-18 10:57:10 +0000
+++ debian/mediascanner2.0.install	2014-05-24 09:41:18 +0000
@@ -1,2 +1,4 @@
 usr/bin/*
+usr/lib/*/mediascanner-2.0/mediascanner-dbus-2.0
+usr/share/dbus-1/services/*
 usr/share/upstart/sessions/*

=== modified file 'src/mediascanner/Album.cc'
--- src/mediascanner/Album.cc	2014-01-31 08:21:13 +0000
+++ src/mediascanner/Album.cc	2014-05-24 09:41:18 +0000
@@ -23,6 +23,9 @@
 
 namespace mediascanner {
 
+Album::Album() {
+}
+
 Album::Album(const std::string &title, const std::string &artist)
     : title(title), artist(artist) {
 }

=== modified file 'src/mediascanner/Album.hh'
--- src/mediascanner/Album.hh	2014-01-31 08:21:13 +0000
+++ src/mediascanner/Album.hh	2014-05-24 09:41:18 +0000
@@ -27,8 +27,8 @@
 class Album final {
 public:
 
+    Album();
     Album(const std::string &title, const std::string &artist);
-    Album() = delete;
 
     const std::string& getTitle() const noexcept;
     const std::string& getArtist() const noexcept;

=== modified file 'src/mediascanner/MediaFile.cc'
--- src/mediascanner/MediaFile.cc	2014-05-24 09:41:18 +0000
+++ src/mediascanner/MediaFile.cc	2014-05-24 09:41:18 +0000
@@ -26,6 +26,9 @@
 
 namespace mediascanner {
 
+MediaFile::MediaFile() : p(new MediaFilePrivate) {
+}
+
 MediaFile::MediaFile(const MediaFile &other) :
     p(new MediaFilePrivate(*other.p)) {
 }

=== modified file 'src/mediascanner/MediaFile.hh'
--- src/mediascanner/MediaFile.hh	2014-05-24 09:41:18 +0000
+++ src/mediascanner/MediaFile.hh	2014-05-24 09:41:18 +0000
@@ -32,7 +32,7 @@
     friend class MediaFileBuilder;
 public:
 
-    MediaFile() = delete;
+    MediaFile();
     MediaFile(const MediaFile &other);
     MediaFile(const MediaFileBuilder &builder);
     MediaFile(MediaFileBuilder &&builder);

=== modified file 'src/mediascanner/MediaStore.cc'
--- src/mediascanner/MediaStore.cc	2014-05-24 09:41:18 +0000
+++ src/mediascanner/MediaStore.cc	2014-05-24 09:41:18 +0000
@@ -514,7 +514,7 @@
     return collect_albums(query);
 }
 
-vector<std::string> MediaStore::listArtists(bool album_artists, int limit) {
+vector<std::string> MediaStore::listArtists(bool album_artists, int limit) const {
     const char *qs;
 
     if (album_artists) {

=== modified file 'src/mediascanner/MediaStore.hh'
--- src/mediascanner/MediaStore.hh	2014-02-28 06:47:48 +0000
+++ src/mediascanner/MediaStore.hh	2014-05-24 09:41:18 +0000
@@ -55,7 +55,7 @@
     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);
+    std::vector<std::string> listArtists(bool album_artists, int limit=-1) const;
 
     size_t size() const;
     void pruneDeleted();

=== added directory 'src/ms-dbus'
=== added file 'src/ms-dbus/CMakeLists.txt'
--- src/ms-dbus/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/CMakeLists.txt	2014-05-24 09:41:18 +0000
@@ -0,0 +1,33 @@
+include_directories(..)
+add_definitions(${MEDIASCANNER_CFLAGS} ${DBUSCPP_CFLAGS})
+
+add_library(ms-dbus STATIC
+  dbus-codec.cc
+  service-skeleton.cc
+  service-stub.cc
+)
+
+target_link_libraries(ms-dbus mediascanner ${DBUSCPP_LDFLAGS})
+# Compile with -fPIC, since this code is linked into the QML plugin.
+set_target_properties(ms-dbus PROPERTIES COMPILE_FLAGS "-fPIC")
+
+add_executable(mediascanner-dbus
+  main.cc
+)
+target_link_libraries(mediascanner-dbus ms-dbus)
+set_target_properties(mediascanner-dbus
+  PROPERTIES OUTPUT_NAME "mediascanner-dbus-2.0")
+
+install(
+  TARGETS mediascanner-dbus
+  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/mediascanner-2.0
+)
+
+configure_file(
+  com.canonical.MediaScanner2.service.in
+  com.canonical.MediaScanner2.service)
+
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.MediaScanner2.service
+  DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services
+)

=== added file 'src/ms-dbus/com.canonical.MediaScanner2.service.in'
--- src/ms-dbus/com.canonical.MediaScanner2.service.in	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/com.canonical.MediaScanner2.service.in	2014-05-24 09:41:18 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.Thumbnailer
+Exec=@CMAKE_INSTALL_LIBDIR@/mediascanner-2.0/mediascanner-dbus-2.0

=== added file 'src/ms-dbus/dbus-codec.cc'
--- src/ms-dbus/dbus-codec.cc	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/dbus-codec.cc	2014-05-24 09:41:18 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2013 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 <cstdint>
+#include <string>
+
+#include <core/dbus/object.h>
+
+#include <mediascanner/MediaFile.hh>
+#include <mediascanner/MediaFileBuilder.hh>
+#include <mediascanner/Album.hh>
+#include "dbus-codec.hh"
+
+using core::dbus::Message;
+using core::dbus::Codec;
+using mediascanner::MediaFile;
+using mediascanner::MediaFileBuilder;
+using mediascanner::MediaType;
+using mediascanner::Album;
+using std::string;
+
+void Codec<MediaFile>::encode_argument(Message::Writer &out, const MediaFile &file) {
+    auto w = out.open_structure();
+    core::dbus::encode_argument(w, file.getFileName());
+    core::dbus::encode_argument(w, file.getContentType());
+    core::dbus::encode_argument(w, file.getETag());
+    core::dbus::encode_argument(w, file.getTitle());
+    core::dbus::encode_argument(w, file.getAuthor());
+    core::dbus::encode_argument(w, file.getAlbum());
+    core::dbus::encode_argument(w, file.getAlbumArtist());
+    core::dbus::encode_argument(w, file.getDate());
+    core::dbus::encode_argument(w, file.getGenre());
+    core::dbus::encode_argument(w, (int32_t)file.getDiscNumber());
+    core::dbus::encode_argument(w, (int32_t)file.getTrackNumber());
+    core::dbus::encode_argument(w, (int32_t)file.getDuration());
+    core::dbus::encode_argument(w, (int32_t)file.getType());
+    out.close_structure(std::move(w));
+}
+
+void Codec<MediaFile>::decode_argument(Message::Reader &in, MediaFile &file) {
+    auto r = in.pop_structure();
+    string filename, content_type, etag, title, author;
+    string album, album_artist, date, genre;
+    int32_t disc_number, track_number, duration, type;
+    r >> filename >> content_type >> etag >> title >> author
+      >> album >> album_artist >> date >> genre
+      >> disc_number >> track_number >> duration >> type;
+    file = MediaFileBuilder(filename)
+        .setContentType(content_type)
+        .setETag(etag)
+        .setTitle(title)
+        .setAuthor(author)
+        .setAlbum(album)
+        .setAlbumArtist(album_artist)
+        .setDate(date)
+        .setGenre(genre)
+        .setDiscNumber(disc_number)
+        .setTrackNumber(track_number)
+        .setDuration(duration)
+        .setType((MediaType)type);
+}
+
+void Codec<Album>::encode_argument(Message::Writer &out, const Album &album) {
+    auto w = out.open_structure();
+    core::dbus::encode_argument(w, album.getTitle());
+    core::dbus::encode_argument(w, album.getArtist());
+    out.close_structure(std::move(w));
+}
+
+void Codec<Album>::decode_argument(Message::Reader &in, Album &album) {
+    auto r = in.pop_structure();
+    string title, artist;
+    r >> title >> artist;
+    album = Album(title, artist);
+}

=== added file 'src/ms-dbus/dbus-codec.hh'
--- src/ms-dbus/dbus-codec.hh	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/dbus-codec.hh	2014-05-24 09:41:18 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2013 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_DBUS_CODEC_HH
+#define MEDIASCANNER_DBUS_CODEC_HH
+
+#include <string>
+
+#include <core/dbus/codec.h>
+#include <core/dbus/helper/type_mapper.h>
+
+namespace mediascanner {
+class MediaFile;
+class Album;
+}
+
+namespace core {
+namespace dbus {
+
+template <>
+struct Codec<mediascanner::MediaFile> {
+    static void encode_argument(Message::Writer &out, const mediascanner::MediaFile &file);
+    static void decode_argument(Message::Reader &in, mediascanner::MediaFile &file);
+};
+
+template <>
+struct Codec<mediascanner::Album> {
+    static void encode_argument(Message::Writer &out, const mediascanner::Album &album);
+    static void decode_argument(Message::Reader &in, mediascanner::Album &album);
+};
+
+namespace helper {
+
+template<>
+struct TypeMapper<mediascanner::MediaFile> {
+    constexpr static ArgumentType type_value() {
+        return ArgumentType::structure;
+    }
+    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 = "(sssssssssiiii)";
+        return s;
+    }
+};
+
+template<>
+struct TypeMapper<mediascanner::Album> {
+    constexpr static ArgumentType type_value() {
+        return ArgumentType::structure;
+    }
+    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 = "(ss)";
+        return s;
+    }
+};
+
+}
+
+}
+}
+#endif

=== added file 'src/ms-dbus/dbus-interface.hh'
--- src/ms-dbus/dbus-interface.hh	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/dbus-interface.hh	2014-05-24 09:41:18 +0000
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2013 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_DBUS_INTERFACE_HH
+#define MEDIASCANNER_DBUS_INTERFACE_HH
+
+#include <chrono>
+#include <string>
+
+#include <core/dbus/object.h>
+#include <core/dbus/service.h>
+
+namespace mediascanner {
+namespace dbus {
+
+struct MediaStoreInterface {
+    inline static const std::string& name() {
+        static std::string s = "com.canonical.MediaScanner2";
+        return s;
+    }
+
+    struct Errors {
+        struct Error {
+            inline static const std::string& name() {
+                static std::string s = "com.canonical.MediaScanner2.Error";
+                return s;
+            }
+        };
+    };
+
+    struct Lookup {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "Lookup";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct Query {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "Query";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct QueryAlbums {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "QueryAlbums";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct GetAlbumSongs {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "GetAlbumSongs";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct GetETag {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "GetETag";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct ListSongs {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "ListSongs";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct ListAlbums {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "ListAlbums";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+
+    struct ListArtists {
+        typedef MediaStoreInterface Interface;
+
+        inline static const std::string& name() {
+            static std::string s = "ListArtists";
+            return s;
+        }
+
+        inline static const std::chrono::milliseconds default_timeout() {
+            return std::chrono::seconds{1};
+        }
+    };
+};
+
+}
+}
+#endif

=== added file 'src/ms-dbus/main.cc'
--- src/ms-dbus/main.cc	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/main.cc	2014-05-24 09:41:18 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2013 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 <memory>
+#include <core/dbus/bus.h>
+#include <core/dbus/asio/executor.h>
+
+#include <mediascanner/MediaStore.hh>
+#include "service-skeleton.hh"
+
+using namespace mediascanner;
+
+int main(int , char **) {
+    auto bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::session);
+    bus->install_executor(core::dbus::asio::make_executor(bus));
+
+    auto store = std::make_shared<MediaStore>(MS_READ_ONLY);
+
+    dbus::ServiceSkeleton service(bus, store);
+    service.run();
+    return 0;
+}

=== added file 'src/ms-dbus/service-skeleton.cc'
--- src/ms-dbus/service-skeleton.cc	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/service-skeleton.cc	2014-05-24 09:41:18 +0000
@@ -0,0 +1,232 @@
+#include <stdexcept>
+
+#include <core/dbus/message.h>
+#include <core/dbus/object.h>
+#include <core/dbus/types/object_path.h>
+
+#include <mediascanner/Album.hh>
+#include <mediascanner/MediaFile.hh>
+#include <mediascanner/MediaStore.hh>
+
+#include "dbus-interface.hh"
+#include "dbus-codec.hh"
+#include "service-skeleton.hh"
+
+using core::dbus::Message;
+
+namespace mediascanner {
+namespace dbus {
+
+struct ServiceSkeleton::Private {
+    ServiceSkeleton *impl;
+    std::shared_ptr<MediaStore> store;
+    core::dbus::Object::Ptr object;
+
+    Private(ServiceSkeleton *impl, std::shared_ptr<MediaStore> store) :
+        impl(impl),
+        store(store),
+        object(impl->access_service()->add_object_for_path(
+                   core::dbus::traits::Service<MediaStoreService>::object_path())) {
+        object->install_method_handler<MediaStoreInterface::Lookup>(
+            std::bind(
+                &Private::handle_lookup,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::Query>(
+            std::bind(
+                &Private::handle_query,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::QueryAlbums>(
+            std::bind(
+                &Private::handle_query_albums,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::GetAlbumSongs>(
+            std::bind(
+                &Private::handle_get_album_songs,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::GetETag>(
+            std::bind(
+                &Private::handle_get_etag,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::ListSongs>(
+            std::bind(
+                &Private::handle_list_songs,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::ListAlbums>(
+            std::bind(
+                &Private::handle_list_albums,
+                this,
+                std::placeholders::_1));
+        object->install_method_handler<MediaStoreInterface::ListArtists>(
+            std::bind(
+                &Private::handle_list_artists,
+                this,
+                std::placeholders::_1));
+    }
+
+    void handle_lookup(const Message::Ptr &message) {
+        std::string filename;
+        message->reader() >> filename;
+        Message::Ptr reply;
+        try {
+            MediaFile file = store->lookup(filename);
+            reply = Message::make_method_return(message);
+            reply->writer() << file;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_query(const Message::Ptr &message) {
+        std::string query;
+        int32_t type;
+        int32_t limit;
+
+        message->reader() >> query >> type >> limit;
+        Message::Ptr reply;
+        try {
+            auto results = store->query(query, (MediaType)type, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << results;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_query_albums(const Message::Ptr &message) {
+        std::string query;
+        int32_t limit;
+
+        message->reader() >> query >> limit;
+        Message::Ptr reply;
+        try {
+            auto albums = store->queryAlbums(query, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << albums;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_get_album_songs(const Message::Ptr &message) {
+        Album album("", "");
+
+        message->reader() >> album;
+        Message::Ptr reply;
+        try {
+            auto results = store->getAlbumSongs(album);
+            reply = Message::make_method_return(message);
+            reply->writer() << results;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_get_etag(const Message::Ptr &message) {
+        std::string filename;
+        message->reader() >> filename;
+
+        Message::Ptr reply;
+        try {
+            std::string etag = store->getETag(filename);
+            reply = Message::make_method_return(message);
+            reply->writer() << etag;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_list_songs(const Message::Ptr &message) {
+        std::string artist, album, album_artist;
+        int32_t limit;
+
+        message->reader() >> artist >> album >> album_artist >> limit;
+        Message::Ptr reply;
+        try {
+            auto results = store->listSongs(artist, album, album_artist, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << results;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_list_albums(const Message::Ptr &message) {
+        std::string artist, album_artist;
+        int32_t limit;
+
+        message->reader() >> artist >> album_artist >> limit;
+        Message::Ptr reply;
+        try {
+            auto albums = store->listAlbums(artist, album_artist, limit);
+            reply = Message::make_method_return(message);
+            reply->writer() << albums;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+
+    void handle_list_artists(const Message::Ptr &message) {
+        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;
+        } catch (const std::exception &e) {
+            reply = Message::make_error(
+                message, MediaStoreInterface::Errors::Error::name(),
+                e.what());
+        }
+        impl->access_bus()->send(reply);
+    }
+};
+
+ServiceSkeleton::ServiceSkeleton(core::dbus::Bus::Ptr bus,
+                                 std::shared_ptr<MediaStore> store) :
+    core::dbus::Skeleton<MediaStoreService>(bus),
+    p(new Private(this, store)) {
+}
+
+ServiceSkeleton::~ServiceSkeleton() {
+}
+
+void ServiceSkeleton::run() {
+    access_bus()->run();
+}
+
+void ServiceSkeleton::stop() {
+    access_bus()->stop();
+}
+
+}
+}

=== added file 'src/ms-dbus/service-skeleton.hh'
--- src/ms-dbus/service-skeleton.hh	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/service-skeleton.hh	2014-05-24 09:41:18 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2013 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_DBUS_SERVICE_SKELETON_HH
+#define MEDIASCANNER_DBUS_SERVICE_SKELETON_HH
+
+#include <memory>
+#include <core/dbus/bus.h>
+#include <core/dbus/skeleton.h>
+
+#include "service.hh"
+
+namespace mediascanner {
+
+class MediaStore;
+
+namespace dbus {
+
+class ServiceSkeleton : public core::dbus::Skeleton<MediaStoreService> {
+public:
+    ServiceSkeleton(core::dbus::Bus::Ptr bus, std::shared_ptr<MediaStore> store);
+    ~ServiceSkeleton();
+
+    void run();
+    void stop();
+
+private:
+    struct Private;
+    std::unique_ptr<Private> p;
+};
+
+}
+}
+
+#endif

=== added file 'src/ms-dbus/service-stub.cc'
--- src/ms-dbus/service-stub.cc	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/service-stub.cc	2014-05-24 09:41:18 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2013 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 <stdexcept>
+
+#include <mediascanner/Album.hh>
+#include <mediascanner/MediaFile.hh>
+#include "service-stub.hh"
+#include "dbus-interface.hh"
+#include "dbus-codec.hh"
+
+using std::string;
+
+namespace mediascanner {
+namespace dbus {
+
+struct ServiceStub::Private
+{
+    core::dbus::Object::Ptr object;
+};
+
+ServiceStub::ServiceStub(core::dbus::Bus::Ptr bus)
+    : core::dbus::Stub<MediaStoreService>(bus),
+      p(new Private{access_service()->object_for_path(
+                  core::dbus::types::ObjectPath(core::dbus::traits::Service<MediaStoreService>::object_path()))}) {
+}
+
+ServiceStub::~ServiceStub() {
+}
+
+MediaFile ServiceStub::lookup(const string &filename) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::Lookup, MediaFile>(filename);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<MediaFile> ServiceStub::query(const string &q, MediaType type, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::Query, std::vector<MediaFile>>(q, (int32_t)type, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<Album> ServiceStub::queryAlbums(const string &core_term, int limit) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::QueryAlbums, std::vector<Album>>(core_term, (int32_t)limit);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+std::vector<MediaFile> ServiceStub::getAlbumSongs(const Album& album) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::GetAlbumSongs, std::vector<MediaFile>>(album);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+string ServiceStub::getETag(const string &filename) const {
+    auto result = p->object->invoke_method_synchronously<MediaStoreInterface::GetETag, string>(filename);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    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);
+    if (result.is_error())
+        throw std::runtime_error(result.error().print());
+    return result.value();
+}
+
+}
+}

=== added file 'src/ms-dbus/service-stub.hh'
--- src/ms-dbus/service-stub.hh	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/service-stub.hh	2014-05-24 09:41:18 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2013 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_DBUS_SERVICE_STUB_HH
+#define MEDIASCANNER_DBUS_SERVICE_STUB_HH
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <core/dbus/bus.h>
+#include <core/dbus/stub.h>
+
+#include <mediascanner/scannercore.hh>
+#include "service.hh"
+
+namespace mediascanner {
+
+class Album;
+class MediaFile;
+
+namespace dbus {
+
+class ServiceStub : public core::dbus::Stub<MediaStoreService> {
+public:
+    ServiceStub(core::dbus::Bus::Ptr bus);
+    ~ServiceStub();
+
+    MediaFile lookup(const std::string &filename) const;
+    std::vector<MediaFile> query(const std::string &q, MediaType type, int limit=-1) const;
+    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;
+
+private:
+    struct Private;
+    std::unique_ptr<Private> p;
+};
+
+}
+}
+
+#endif

=== added file 'src/ms-dbus/service.hh'
--- src/ms-dbus/service.hh	1970-01-01 00:00:00 +0000
+++ src/ms-dbus/service.hh	2014-05-24 09:41:18 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2013 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_DBUS_SERVICE_HH
+#define MEDIASCANNER_DBUS_SERVICE_HH
+
+#include <core/dbus/traits/service.h>
+
+namespace mediascanner {
+namespace dbus {
+
+class MediaStoreService {
+public:
+    MediaStoreService() {}
+
+    MediaStoreService(const MediaStoreService&) = delete;
+    virtual ~MediaStoreService() = default;
+
+    MediaStoreService& operator=(const MediaStoreService&) = delete;
+    bool operator==(const MediaStoreService&) const = delete;
+};
+
+}
+}
+
+namespace core {
+namespace dbus {
+namespace traits {
+
+template<>
+struct Service<mediascanner::dbus::MediaStoreService> {
+    inline static const std::string& interface_name() {
+        static const std::string iface("com.canonical.MediaScaner2");
+        return iface;
+    }
+    inline static const std::string& object_path() {
+        static const std::string path("/com/canonical/MediaScanner2");
+        return path;
+    }
+};
+
+}
+}
+}
+
+#endif

=== modified file 'src/qml/Ubuntu/MediaScanner/CMakeLists.txt'
--- src/qml/Ubuntu/MediaScanner/CMakeLists.txt	2014-03-24 10:04:19 +0000
+++ src/qml/Ubuntu/MediaScanner/CMakeLists.txt	2014-05-24 09:41:18 +0000
@@ -1,4 +1,5 @@
 include_directories(../../..)
+add_definitions(${DBUSCPP_CFLAGS} -DQT_NO_KEYWORDS)
 
 set(QML_PLUGIN_DIR "${CMAKE_INSTALL_LIBDIR}/qt5/qml/Ubuntu/MediaScanner.0.1")
 
@@ -17,7 +18,7 @@
 
 set_target_properties(mediascanner-qml PROPERTIES AUTOMOC TRUE)
 qt5_use_modules(mediascanner-qml Qml)
-target_link_libraries(mediascanner-qml mediascanner)
+target_link_libraries(mediascanner-qml mediascanner ms-dbus)
 
 install(
   TARGETS mediascanner-qml

=== modified file 'src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.cc'
--- src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.cc	2014-02-27 08:01:05 +0000
+++ src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.cc	2014-05-24 09:41:18 +0000
@@ -20,10 +20,24 @@
 #include "MediaStoreWrapper.hh"
 #include <QQmlEngine>
 
+#include <core/dbus/asio/executor.h>
+#include <ms-dbus/service-stub.hh>
+
 using namespace mediascanner::qml;
 
+static core::dbus::Bus::Ptr the_session_bus() {
+    static core::dbus::Bus::Ptr bus = std::make_shared<core::dbus::Bus>(
+        core::dbus::WellKnownBus::session);
+    static core::dbus::Executor::Ptr executor = core::dbus::asio::make_executor(bus);
+    static std::once_flag once;
+
+    std::call_once(once, []() {bus->install_executor(executor);});
+
+    return bus;
+}
+
 MediaStoreWrapper::MediaStoreWrapper(QObject *parent)
-    : QObject(parent), store(MS_READ_ONLY) {
+    : QObject(parent), store(the_session_bus()) {
 }
 
 QList<QObject*> MediaStoreWrapper::query(const QString &q, MediaType type) {

=== modified file 'src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.hh'
--- src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.hh	2014-02-27 08:01:05 +0000
+++ src/qml/Ubuntu/MediaScanner/MediaStoreWrapper.hh	2014-05-24 09:41:18 +0000
@@ -24,10 +24,11 @@
 #include <QObject>
 #include <QString>
 
-#include <mediascanner/MediaStore.hh>
+#include <ms-dbus/service-stub.hh>
 #include "MediaFileWrapper.hh"
 
 namespace mediascanner {
+
 namespace qml {
 
 class MediaStoreWrapper : public QObject {
@@ -44,7 +45,7 @@
     Q_INVOKABLE QList<QObject*> query(const QString &q, MediaType type);
     Q_INVOKABLE mediascanner::qml::MediaFileWrapper *lookup(const QString &filename);
 
-    mediascanner::MediaStore store;
+    mediascanner::dbus::ServiceStub store;
 };
 
 }

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2014-05-02 08:53:16 +0000
+++ test/CMakeLists.txt	2014-05-24 09:41:18 +0000
@@ -17,7 +17,7 @@
     set_target_properties(gtest PROPERTIES COMPILE_FLAGS "-Wno-unused-private-field")
 endif()
 
-add_definitions(${MEDIASCANNER_CFLAGS} ${GST_CFLAGS})
+add_definitions(${MEDIASCANNER_CFLAGS} ${GST_CFLAGS} ${DBUSCPP_CFLAGS} -DQT_NO_KEYWORDS)
 include_directories(../src)
 
 configure_file(test_config.h.in test_config.h)
@@ -43,9 +43,13 @@
 target_link_libraries(test_mfbuilder gtest mediascanner)
 add_test(test_mfbuilder test_mfbuilder)
 
+add_executable(test_dbus test_dbus.cc)
+target_link_libraries(test_dbus gtest mediascanner ms-dbus)
+add_test(test_dbus test_dbus)
+
 add_executable(test_qml test_qml.cc)
 qt5_use_modules(test_qml QuickTest)
-target_link_libraries(test_qml mediascanner)
+target_link_libraries(test_qml mediascanner ${DBUSCPP_LDFLAGS})
 add_test(test_qml test_qml -input ${CMAKE_CURRENT_SOURCE_DIR}/qml -import ${CMAKE_BINARY_DIR}/src/qml)
 set_tests_properties(test_qml
   PROPERTIES ENVIRONMENT "QT_QPA_PLATFORM=minimal")

=== added file 'test/test_dbus.cc'
--- test/test_dbus.cc	1970-01-01 00:00:00 +0000
+++ test/test_dbus.cc	2014-05-24 09:41:18 +0000
@@ -0,0 +1,67 @@
+#include <gtest/gtest.h>
+#include <core/dbus/message.h>
+#include <core/dbus/object.h>
+#include <core/dbus/types/object_path.h>
+
+#include <mediascanner/Album.hh>
+#include <mediascanner/MediaFile.hh>
+#include <mediascanner/MediaFileBuilder.hh>
+#include <ms-dbus/dbus-codec.hh>
+
+class MediaStoreDBusTests : public ::testing::Test {
+};
+
+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")
+        .setDate("1900")
+        .setTitle("b")
+        .setAuthor("c")
+        .setAlbum("d")
+        .setAlbumArtist("e")
+        .setGenre("f")
+        .setDiscNumber(0)
+        .setTrackNumber(1)
+        .setDuration(5)
+        .setType(mediascanner::AudioMedia);
+    message->writer() << media;
+
+    EXPECT_EQ("(sssssssssiiii)", message->signature());
+    EXPECT_EQ(core::dbus::helper::TypeMapper<mediascanner::MediaFile>::signature(), message->signature());
+
+    mediascanner::MediaFile media2;
+    message->reader() >> media2;
+    EXPECT_EQ(media, media2);
+}
+
+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;
+
+    EXPECT_EQ("(ss)", message->signature());
+    EXPECT_EQ(core::dbus::helper::TypeMapper<mediascanner::Album>::signature(), message->signature());
+
+    mediascanner::Album album2;
+    message->reader() >> album2;
+    EXPECT_EQ("title", album2.getTitle());
+    EXPECT_EQ("artist", album2.getArtist());
+    EXPECT_EQ(album, album2);
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

=== modified file 'test/test_qml.cc'
--- test/test_qml.cc	2014-05-24 09:41:18 +0000
+++ test/test_qml.cc	2014-05-24 09:41:18 +0000
@@ -1,12 +1,19 @@
 #include <stdlib.h>
+#include <cstdio>
+#include <memory>
 #include <string>
 
+#include <QProcess>
 #include <QtQuickTest/quicktest.h>
 
+#include <core/dbus/fixture.h>
+
 #include <mediascanner/MediaStore.hh>
 #include <mediascanner/MediaFile.hh>
 #include <mediascanner/MediaFileBuilder.hh>
 
+#include "test_config.h"
+
 using namespace mediascanner;
 
 class MediaStoreData {
@@ -18,8 +25,29 @@
         }
         setenv("MEDIASCANNER_CACHEDIR", db_path.c_str(), true);
         populate();
+
+        // Start up private bus, and start daemon.
+        dbus_fixture.reset(
+            new core::dbus::Fixture(
+                core::dbus::Fixture::default_session_bus_config_file(),
+                core::dbus::Fixture::default_system_bus_config_file()));
+
+        daemon.setProgram(TEST_DIR "/../src/ms-dbus/mediascanner-dbus-2.0");
+        daemon.setProcessChannelMode(QProcess::ForwardedChannels);
+        daemon.start();
+        daemon.closeWriteChannel();
+        if (!daemon.waitForStarted()) {
+            throw std::runtime_error("Failed to start mediascanner-dbus-2.0");
+        }
     }
     ~MediaStoreData() {
+        daemon.kill();
+        if (!daemon.waitForFinished()) {
+            fprintf(stderr, "Failed to stop mediascanner-dbus-2.0\n");
+        }
+
+        dbus_fixture.reset();
+
         if (system("rm -rf \"$MEDIASCANNER_CACHEDIR\"") == -1) {
             throw std::runtime_error("rm -rf failed");
         }
@@ -126,6 +154,8 @@
 
 private:
     std::string db_path;
+    std::unique_ptr<core::dbus::Fixture> dbus_fixture;
+    QProcess daemon;
 };
 
 MediaStoreData data;