Merge lp:~mhr3/unity/update-core-preview-api into lp:unity

[Michal Hruby]

Updated the Preview API present in UnityCore to match latest protocol used by libunity

Updated the Preview API present in UnityCore to match latest protocol used by libunity.

Added both deserialization unit-tests as well as communication integration tests with the testlens service.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2436
http://s-jenkins:8080/job/unity-ci/45/

review: Needs Fixing (continuous-integration)

[Gord Allott (gordallott)]

303 + //unsigned int date_modified;
304 + //unsigned int size;
305 + //std::string type;

probably don't want to leave commented out stuff in public headers

apart from that, had a few q's resolved over irc, approving here.

review: Approve

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2437
http://s-jenkins:8080/job/unity-ci/46/

review: Needs Fixing (continuous-integration)

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2438
http://s-jenkins:8080/job/unity-ci/47/

review: Needs Fixing (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

+ glib::Object<GIcon> icon(unity_protocol_application_preview_get_app_icon(preview),
93 + glib::AddRef());
94 + app_icon_ = icon;

doing just:

app_icon_ = unity_protocol_application_preview_get_app_icon(preview)

does not work here?

+ glib::String activation_uri(g_strdup_printf("%s:%s", action_id.c_str(), uri.c_str()));

Why not instead:
std::string activation_uri = action_id + ":" + uri;

 std::string renderer_name(
1125 + unity_protocol_preview_get_renderer_name(
1126 + UNITY_PROTOCOL_PREVIEW(proto_obj.RawPtr())));

I've read this is always non-null... But maybe a check can avoid any change on the library side...

[Michal Hruby (mhr3)]

> + glib::Object<GIcon>
> icon(unity_protocol_application_preview_get_app_icon(preview),
> 93 + glib::AddRef());
> 94 + app_icon_ = icon;
>
> doing just:
>
> app_icon_ = unity_protocol_application_preview_get_app_icon(preview)
>
> does not work here?

Wouldn't that try to consume a reference which is doesn't get? (_get_app_icon() return unowned instance)

>
> + glib::String activation_uri(g_strdup_printf("%s:%s", action_id.c_str(),
> uri.c_str()));
>
> Why not instead:
> std::string activation_uri = action_id + ":" + uri;
>

Fewer temporary objects? :)

> std::string renderer_name(
> 1125 + unity_protocol_preview_get_renderer_name(
> 1126 + UNITY_PROTOCOL_PREVIEW(proto_obj.RawPtr())));
>
> I've read this is always non-null... But maybe a check can avoid any change on
> the library side...

I'd rather keep it this way, this call returning null would be a bug in the library, if that ever happens we'd notice it easier.

[Marco Trevisan (Treviño) (3v1n0)]

> > app_icon_ = unity_protocol_application_preview_get_app_icon(preview)
> >
> > does not work here?
>
> Wouldn't that try to consume a reference which is doesn't get?
> (_get_app_icon() return unowned instance)

Ah, ok if you need to reference it, that's fine. Using a temporary object should be fine as well...

> > + glib::String activation_uri(g_strdup_printf("%s:%s", action_id.c_str(),
> > uri.c_str()));
> >
> > Why not instead:
> > std::string activation_uri = action_id + ":" + uri;
> >
>
> Fewer temporary objects? :)

Oh, yes... But as it doesn't seem a so critical code path, I thought you could have been more C++ friendly, without the need to allocate a glib::String, free it and generate a new std::string.
If you just want to avoid temporary objects, you can have the same with:

std::string activation_uri = action_id;
activation_uri += ':';
activation_uri += uri;

[Michal Hruby (mhr3)]

> Oh, yes... But as it doesn't seem a so critical code path, I thought you could
> have been more C++ friendly, without the need to allocate a glib::String, free
> it and generate a new std::string.
> If you just want to avoid temporary objects, you can have the same with:
>
> std::string activation_uri = action_id;
> activation_uri += ':';
> activation_uri += uri;

Ok, if you like std::strings so much :)

[Marco Trevisan (Treviño) (3v1n0)]

Good! I like C++11 pimpl's ;)

review: Approve

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2439
http://s-jenkins:8080/job/unity-ci/52/

review: Needs Fixing (continuous-integration)

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2440
http://s-jenkins:8080/job/unity-ci/54/

review: Needs Fixing (continuous-integration)

[Nick Dedekind (nick-dedekind)]

Couple of ommissions:
dash::Preview::layout_hint needs enumeration.
dash::ApplicationPreview is missing rating info from protocol object.

[Michal Hruby (mhr3)]

> Couple of ommissions:
> dash::Preview::layout_hint needs enumeration.
> dash::ApplicationPreview is missing rating info from protocol object.

Fixed.

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/922/console reported an error when processing this lp:~mhr3/unity/update-core-preview-api branch.
Not merging it.

[Timo Jyrinki (timo-jyrinki)]

As a comment, even giving LD_LIBRARY_PATH=$(LD_LIBRARY_PATH):/usr/lib/x86_64-linux-gnu/libunity manually to dh_makeshlibs does not help here. So that suggestion in the build log seems misleading.

One can reproduce the build problem with bzr branch lp:ubuntu/unity, bzr merge lp:unity, bzr merge lp:~mhr3/unity/update-core-preview-api, bzr bd

So far I haven't found how private libraries from other packages should be properly used.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2442
http://jenkins.qa.ubuntu.com/job/unity-ci/65/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=amd64/65/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=i386/65/console

review: Needs Fixing (continuous-integration)

[Martin Mrazik (mrazik)]

The jenkins failure above (unity-ci job) is because of connectivity issues to us.archive.ubuntu.com. Sorry for false negative.

[lp:~mhr3/unity/update-core-preview-api]

2443. By Michal Hruby on 2012-07-17

Use enum for Track play_state, not just a bool

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2443
http://jenkins.qa.ubuntu.com/job/unity-ci/87/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=amd64/87/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=i386/87/console

review: Needs Fixing (continuous-integration)

[lp:~mhr3/unity/update-core-preview-api]

2444. By Michal Hruby on 2012-07-17

Merge trunk

2445. By Michal Hruby on 2012-07-17

Get rid of NoReplyCallback usage, as it disappeared

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2445
http://jenkins.qa.ubuntu.com/job/unity-ci/88/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=amd64/88/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-ci/./distribution=quantal,flavor=i386/88/console

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-07-09 07:51:54 +0000
+++ CMakeLists.txt	2012-07-17 13:45:25 +0000
@@ -133,8 +133,8 @@
 #
 # Compiz Plugins
 #
-
-set (UNITY_PLUGIN_DEPS "compiz;nux-3.0>=3.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4>=0.4.90;atk;unity-misc>=0.4.0;gconf-2.0;libutouch-geis;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;xfixes")
+set (UNITY_PLUGIN_DEPS "compiz;nux-3.0>=3.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4>=0.4.90;atk;unity-misc>=0.4.0;gconf-2.0;libutouch-geis;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;xfixes;unity-protocol-private")
+# FIXME: unity-protocol-private shouldn't be there, but building of unityshell is just broken
 
 find_package (PkgConfig)
 pkg_check_modules (CACHED_UNITY_DEPS REQUIRED ${UNITY_PLUGIN_DEPS})

=== modified file 'UnityCore/ApplicationPreview.cpp'
--- UnityCore/ApplicationPreview.cpp	2011-08-02 22:50:10 +0000
+++ UnityCore/ApplicationPreview.cpp	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,8 +15,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
+#include <unity-protocol.h>
+
 #include "ApplicationPreview.h"
 
 namespace unity
@@ -24,24 +27,76 @@
 namespace dash
 {
 
-ApplicationPreview::ApplicationPreview(Preview::Properties& properties)
-  : name(PropertyToString(properties, "name"))
-  , version(PropertyToString(properties, "version"))
-  , size(PropertyToString(properties, "size"))
-  , license(PropertyToString(properties, "license"))
-  , last_updated(PropertyToString(properties, "last-updated"))
-  , rating(PropertyToFloat(properties, "rating"))
-  , n_ratings(PropertyToUnsignedInt(properties, "n-ratings"))
-  , description(PropertyToString(properties, "string"))
-  , icon_hint(PropertyToString(properties, "icon-hint"))
-  , screenshot_icon_hint(PropertyToString(properties, "screenshot-icon-hint"))
-  , primary_action_name(PropertyToString(properties, "primary-action-name"))
-  , primary_action_icon_hint(PropertyToString(properties, "primary-action-icon-hint"))
-  , primary_action_uri(PropertyToString(properties, "primary-action-uri"))
-{
- renderer_name = "preview-application";
-}
-
+class ApplicationPreview::Impl
+{
+public:
+  Impl(ApplicationPreview* owner, glib::Object<GObject> const& proto_obj);
+
+  void SetupGetters();
+  std::string get_last_update() { return last_update_; };
+  std::string get_copyright() { return copyright_; };
+  std::string get_license() { return license_; };
+  glib::Object<GIcon> get_app_icon() { return app_icon_; };
+  float get_rating() const { return rating_; };
+  unsigned int get_num_ratings() const { return num_ratings_; };
+
+  ApplicationPreview* owner_;
+
+  std::string last_update_;
+  std::string copyright_;
+  std::string license_;
+  glib::Object<GIcon> app_icon_;
+  float rating_;
+  unsigned int num_ratings_;
+};
+
+ApplicationPreview::Impl::Impl(ApplicationPreview* owner, glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+{
+  const gchar* s;
+  auto preview = glib::object_cast<UnityProtocolApplicationPreview>(proto_obj);
+
+  s = unity_protocol_application_preview_get_last_update(preview);
+  if (s) last_update_ = s;
+  s = unity_protocol_application_preview_get_copyright(preview);
+  if (s) copyright_ = s;
+  s = unity_protocol_application_preview_get_license(preview);
+  if (s) license_ = s;
+
+  glib::Object<GIcon> icon(unity_protocol_application_preview_get_app_icon(preview),
+                           glib::AddRef());
+  app_icon_ = icon;
+  rating_ = unity_protocol_application_preview_get_rating(preview);
+  num_ratings_ = unity_protocol_application_preview_get_num_ratings(preview);
+      
+  SetupGetters();
+}
+
+void ApplicationPreview::Impl::SetupGetters()
+{
+  owner_->last_update.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_last_update));
+  owner_->copyright.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_copyright));
+  owner_->license.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_license));
+  owner_->app_icon.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_app_icon));
+  owner_->rating.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_rating));
+  owner_->num_ratings.SetGetterFunction(
+            sigc::mem_fun(this, &ApplicationPreview::Impl::get_num_ratings));
+}
+
+ApplicationPreview::ApplicationPreview(unity::glib::Object<GObject> const& proto_obj)
+  : Preview(proto_obj)
+  , pimpl(new Impl(this, proto_obj))
+{
+}
+
+ApplicationPreview::~ApplicationPreview()
+{
+}
 
 }
 }

=== modified file 'UnityCore/ApplicationPreview.h'
--- UnityCore/ApplicationPreview.h	2011-08-02 22:50:10 +0000
+++ UnityCore/ApplicationPreview.h	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
 #ifndef UNITY_APPLICATION_PREVIEW_H
@@ -36,21 +37,19 @@
 public:
   typedef std::shared_ptr<ApplicationPreview> Ptr;
   
-  ApplicationPreview(Preview::Properties& properties);
-
-  std::string name;
-  std::string version;
-  std::string size;
-  std::string license;
-  std::string last_updated;
-  float rating;
-  uint n_ratings;
-  std::string description;
-  std::string icon_hint;
-  std::string screenshot_icon_hint;
-  std::string primary_action_name;
-  std::string primary_action_icon_hint;
-  std::string primary_action_uri;
+  ApplicationPreview(unity::glib::Object<GObject> const& proto_obj);
+  ~ApplicationPreview();
+
+  nux::RWProperty<std::string> last_update;
+  nux::RWProperty<std::string> copyright;
+  nux::RWProperty<std::string> license;
+  nux::RWProperty<glib::Object<GIcon>> app_icon;
+  nux::RWProperty<float> rating;
+  nux::RWProperty<unsigned int> num_ratings;
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
 };
 
 }

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-06-29 21:00:00 +0000
+++ UnityCore/CMakeLists.txt	2012-07-17 13:45:25 +0000
@@ -1,5 +1,5 @@
 find_package (PkgConfig)
-pkg_check_modules (CORE_DEPS REQUIRED glib-2.0 gio-2.0 dee-1.0 sigc++-2.0 nux-core-3.0 gdk-pixbuf-2.0 unity)
+pkg_check_modules (CORE_DEPS REQUIRED glib-2.0 gio-2.0 dee-1.0 sigc++-2.0 nux-core-3.0 gdk-pixbuf-2.0 unity-protocol-private)
 
 execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} unity --variable lensesdir OUTPUT_VARIABLE _lensesdir OUTPUT_STRIP_TRAILING_WHITESPACE)
 
@@ -31,8 +31,9 @@
      Indicators.h
      Lens.h
      Lenses.h
+     MoviePreview.h
      MultiRangeFilter.h
-     MusicPreviews.h
+     MusicPreview.h
      Model.h
      Model-inl.h
      ModelRowAdaptor.h
@@ -42,6 +43,9 @@
      RatingsFilter.h
      Result.h
      Results.h
+     SeriesPreview.h
+     Track.h
+     Tracks.h
      Variant.h
     )
 
@@ -67,14 +71,18 @@
      IndicatorEntry.cpp
      Indicators.cpp
      Lens.cpp
+     MoviePreview.cpp
      MultiRangeFilter.cpp
-     MusicPreviews.cpp
+     MusicPreview.cpp
      ModelRowAdaptor.cpp
      Preview.cpp
      RatingsFilter.cpp
      RadioOptionFilter.cpp
      Result.cpp
      Results.cpp
+     SeriesPreview.cpp
+     Track.cpp
+     Tracks.cpp
      Variant.cpp
     )
 

=== modified file 'UnityCore/Filter.cpp'
--- UnityCore/Filter.cpp	2012-06-18 02:57:23 +0000
+++ UnityCore/Filter.cpp	2012-07-17 13:45:25 +0000
@@ -113,11 +113,6 @@
   ignore_changes_ = ignore;
 }
 
-void Filter::OnModelDestroyed(Filter* self, DeeModel* old_location)
-{
-  self->OnRowRemoved(self->model_, self->iter_);
-}
-
 void Filter::OnRowChanged(DeeModel* model, DeeModelIter* iter)
 {
   if (iter_ != iter || ignore_changes_)
@@ -132,12 +127,17 @@
   filtering.EmitChanged(get_filtering());
 }
 
+void Filter::OnModelDestroyed(Filter* self, DeeModel* old_location)
+{
+  self->model_ = 0;
+  self->OnRowRemoved(old_location, self->iter_);
+}
+
 void Filter::OnRowRemoved(DeeModel* model, DeeModelIter* iter)
 {
   if (iter_ != iter)
     return;
 
-  model_ = 0;
   iter_ = 0;
   removed.emit();
 }

=== modified file 'UnityCore/GenericPreview.cpp'
--- UnityCore/GenericPreview.cpp	2011-08-02 22:58:20 +0000
+++ UnityCore/GenericPreview.cpp	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,8 +15,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
+#include <unity-protocol.h>
+
 #include "GenericPreview.h"
 
 namespace unity
@@ -24,24 +27,13 @@
 namespace dash
 {
 
-GenericPreview::GenericPreview(Preview::Properties& properties)
-  : name(PropertyToString(properties, "name"))
-  , date_modified(PropertyToUnsignedInt(properties, "date-modified"))
-  , size(PropertyToUnsignedInt(properties, "size"))
-  , type(PropertyToString(properties, "type"))
-  , description(PropertyToString(properties, "string"))
-  , icon_hint(PropertyToString(properties, "icon-hint"))
-  , primary_action_name(PropertyToString(properties, "primary-action-name"))
-  , primary_action_icon_hint(PropertyToString(properties, "primary-action-icon-hint"))
-  , primary_action_uri(PropertyToString(properties, "primary-action-uri"))
-  , secondary_action_name(PropertyToString(properties, "secondary-action-name"))
-  , secondary_action_icon_hint(PropertyToString(properties, "secondary-action-icon-hint"))
-  , secondary_action_uri(PropertyToString(properties, "secondary-action-uri"))
-  , tertiary_action_name(PropertyToString(properties, "tertiary-action-name"))
-  , tertiary_action_icon_hint(PropertyToString(properties, "tertiary-action-icon-hint"))
-  , tertiary_action_uri(PropertyToString(properties, "tertiary-action-uri"))
-{
- renderer_name = "preview-generic";
+GenericPreview::GenericPreview(unity::glib::Object<GObject> const& proto_obj)
+  : Preview(proto_obj)
+{
+}
+
+GenericPreview::~GenericPreview()
+{
 }
 
 

=== modified file 'UnityCore/GenericPreview.h'
--- UnityCore/GenericPreview.h	2011-08-02 22:58:20 +0000
+++ UnityCore/GenericPreview.h	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
 #ifndef UNITY_GENERIC_PREVIEW_H
@@ -36,23 +37,8 @@
 public:
   typedef std::shared_ptr<GenericPreview> Ptr;
   
-  GenericPreview(Preview::Properties& properties);
-
-  std::string name;
-  unsigned int date_modified;
-  unsigned int size;
-  std::string type;
-  std::string description;
-  std::string icon_hint;
-  std::string primary_action_name;
-  std::string primary_action_icon_hint;
-  std::string primary_action_uri;
-  std::string secondary_action_name;
-  std::string secondary_action_icon_hint;
-  std::string secondary_action_uri;
-  std::string tertiary_action_name;
-  std::string tertiary_action_icon_hint;
-  std::string tertiary_action_uri;
+  GenericPreview(unity::glib::Object<GObject> const& proto_obj);
+  ~GenericPreview();
 };
 
 }

=== modified file 'UnityCore/Lens.cpp'
--- UnityCore/Lens.cpp	2012-03-14 06:24:18 +0000
+++ UnityCore/Lens.cpp	2012-07-17 13:45:25 +0000
@@ -22,6 +22,7 @@
 #include <gio/gio.h>
 #include <glib.h>
 #include <NuxCore/Logger.h>
+#include <unity-protocol.h>
 
 #include "config.h"
 #include "GLibDBusProxy.h"
@@ -84,7 +85,11 @@
   void Activate(std::string const& uri);
   void ActivationReply(GVariant* parameters);
   void Preview(std::string const& uri);
-  void PreviewReply(GVariant* parameters);
+  void ActivatePreviewAction(std::string const& action_id,
+                             std::string const& uri);
+  void SignalPreview(std::string const& preview_uri,
+                     glib::Variant const& preview_update,
+                     glib::DBusProxy::ReplyCallback reply_cb);
 
   string const& id() const;
   string const& dbus_name() const;
@@ -126,6 +131,7 @@
   glib::DBusProxy* proxy_;
   glib::Object<GCancellable> search_cancellable_;
   glib::Object<GCancellable> global_search_cancellable_;
+  glib::Object<GCancellable> preview_cancellable_;
 
   GVariant *results_variant_;
   GVariant *global_results_variant_;
@@ -495,7 +501,8 @@
     }
 
   proxy_->Call("Activate",
-               g_variant_new("(su)", uri.c_str(), 0),
+               g_variant_new("(su)", uri.c_str(),
+                             UNITY_PROTOCOL_ACTION_TYPE_ACTIVATE_RESULT),
                sigc::mem_fun(this, &Lens::Impl::ActivationReply));
 }
 
@@ -511,7 +518,29 @@
   glib::Variant dict (hints_variant, glib::StealRef());
   dict.ASVToHints(hints);
 
-  owner_->activated.emit(uri.Str(), static_cast<HandledType>(handled), hints);
+  if (handled == UNITY_PROTOCOL_HANDLED_TYPE_SHOW_PREVIEW)
+  {
+    auto iter = hints.find("preview");
+    if (iter != hints.end())
+    {
+      Preview::Ptr preview(Preview::PreviewForVariant(iter->second));
+      if (preview)
+      {
+        // would be nice to make parent_lens a shared_ptr,
+        // but that's not really doable from here
+        preview->parent_lens = owner_;
+        preview->preview_uri = uri.Str();
+        owner_->preview_ready.emit(uri.Str(), preview);
+        return;
+      }
+    }
+
+    LOG_WARNING(logger) << "Unable to deserialize Preview";
+  }
+  else
+  {
+    owner_->activated.emit(uri.Str(), static_cast<HandledType>(handled), hints);
+  }
 }
 
 void Lens::Impl::Preview(std::string const& uri)
@@ -524,26 +553,59 @@
       return;
     }
 
-  proxy_->Call("Preview",
-               g_variant_new("(s)", uri.c_str()),
-               sigc::mem_fun(this, &Lens::Impl::PreviewReply));
-}
-
-void Lens::Impl::PreviewReply(GVariant* parameters)
-{
-  glib::String uri;
-  glib::String renderer_name;
-  GVariant* hints_variant;
-  Hints hints;
-  
-  g_variant_get(parameters, "((ss@a{sv}))", &uri, &renderer_name, &hints_variant);
-
-  glib::Variant dict (hints_variant, glib::StealRef());
-  dict.ASVToHints(hints);
-
-  Preview::Ptr preview = Preview::PreviewForProperties(renderer_name.Str(), hints);
-  owner_->preview_ready.emit(uri.Str(), preview);
-}
+  if (preview_cancellable_)
+  {
+    g_cancellable_cancel(preview_cancellable_);
+  }
+  preview_cancellable_ = g_cancellable_new ();
+
+  proxy_->Call("Activate",
+               g_variant_new("(su)", uri.c_str(),
+                             UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_RESULT),
+               sigc::mem_fun(this, &Lens::Impl::ActivationReply),
+               preview_cancellable_);
+}
+
+void Lens::Impl::ActivatePreviewAction(std::string const& action_id,
+                                       std::string const& uri)
+{
+  LOG_DEBUG(logger) << "Activating action '" << action_id << "' on  '" << id_ << "'";
+
+  if (!proxy_->IsConnected())
+    {
+      LOG_DEBUG(logger) << "Skipping activation. Proxy not connected. ('" << id_ << "')";
+      return;
+    }
+
+  std::string activation_uri(action_id);
+  activation_uri += ":";
+  activation_uri += uri;
+
+  proxy_->Call("Activate",
+               g_variant_new("(su)", activation_uri.c_str(),
+                             UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION),
+               sigc::mem_fun(this, &Lens::Impl::ActivationReply));
+}
+
+void Lens::Impl::SignalPreview(std::string const& preview_uri,
+                               glib::Variant const& preview_update,
+                               glib::DBusProxy::ReplyCallback reply_cb)
+{
+  LOG_DEBUG(logger) << "Signalling preview '" << preview_uri << "' on  '" << id_ << "'";
+
+  if (!proxy_->IsConnected())
+    {
+      LOG_DEBUG(logger) << "Can't signal preview. Proxy not connected. ('" << id_ << "')";
+      return;
+    }
+
+  GVariant *preview_update_variant = preview_update;
+  proxy_->Call("UpdatePreviewProperty",
+               g_variant_new("(s@a{sv})", preview_uri.c_str(),
+                             preview_update_variant),
+               reply_cb);
+}
+
 string const& Lens::Impl::id() const
 {
   return id_;
@@ -702,5 +764,19 @@
   pimpl->Preview(uri);
 }
 
+void Lens::ActivatePreviewAction(std::string const& action_id,
+                                 std::string const& uri)
+{
+  pimpl->ActivatePreviewAction(action_id, uri);
+}
+
+void Lens::SignalPreview(std::string const& uri,
+                         glib::Variant const& preview_update,
+                         glib::DBusProxy::ReplyCallback reply_cb)
+{
+  pimpl->SignalPreview(uri, preview_update, reply_cb);
+}
+
+
 }
 }

=== modified file 'UnityCore/Lens.h'
--- UnityCore/Lens.h	2012-03-14 06:24:18 +0000
+++ UnityCore/Lens.h	2012-07-17 13:45:25 +0000
@@ -26,6 +26,7 @@
 #include <sigc++/trackable.h>
 
 #include "Variant.h"
+#include "GLibDBusProxy.h"
 #include "Categories.h"
 #include "Filters.h"
 #include "Preview.h"
@@ -84,6 +85,11 @@
   virtual void Search(std::string const& search_string);
   virtual void Activate(std::string const& uri);
   virtual void Preview(std::string const& uri);
+  virtual void ActivatePreviewAction(std::string const& action_id,
+                                     std::string const& uri);
+  virtual void SignalPreview(std::string const& uri,
+      glib::Variant const& preview_update,
+      glib::DBusProxy::ReplyCallback reply_cb = nullptr);
 
   nux::RWProperty<std::string> id;
   nux::RWProperty<std::string> dbus_name;
@@ -106,7 +112,7 @@
   sigc::signal<void, Hints const&> search_finished;
   sigc::signal<void, Hints const&> global_search_finished;
   sigc::signal<void, std::string const&, HandledType, Hints const&> activated;
-  sigc::signal<void, std::string const&, Preview::Ptr> preview_ready;
+  sigc::signal<void, std::string const&, Preview::Ptr const&> preview_ready;
 
 private:
   class Impl;

=== modified file 'UnityCore/ModelRowAdaptor.cpp'
--- UnityCore/ModelRowAdaptor.cpp	2011-11-25 02:46:50 +0000
+++ UnityCore/ModelRowAdaptor.cpp	2012-07-17 13:45:25 +0000
@@ -63,6 +63,13 @@
   return dee_model_get_bool(model_, iter_, position);
 }
 
+int RowAdaptorBase::GetIntAt(int position)
+{
+  if (!model_ || !iter_)
+    return 0;
+  return dee_model_get_int32(model_, iter_, position);
+}
+
 unsigned int RowAdaptorBase::GetUIntAt(int position)
 {
   if (!model_ || !iter_)
@@ -70,5 +77,12 @@
   return dee_model_get_uint32(model_, iter_, position);
 }
 
+float RowAdaptorBase::GetFloatAt(int position)
+{
+  if (!model_ || !iter_)
+    return 0.0;
+  return static_cast<float>(dee_model_get_double(model_, iter_, position));
+}
+
 }
 }

=== modified file 'UnityCore/ModelRowAdaptor.h'
--- UnityCore/ModelRowAdaptor.h	2011-07-31 08:39:48 +0000
+++ UnityCore/ModelRowAdaptor.h	2012-07-17 13:45:25 +0000
@@ -54,7 +54,9 @@
 
   std::string GetStringAt(int position);
   bool GetBoolAt(int position);
+  int GetIntAt(int position);
   unsigned int GetUIntAt(int position);
+  float GetFloatAt(int position);
 
   template<typename T>
   void set_renderer(T renderer);

=== added file 'UnityCore/MoviePreview.cpp'
--- UnityCore/MoviePreview.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/MoviePreview.cpp	2012-07-17 13:45:25 +0000
@@ -0,0 +1,82 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011-2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
+ */
+
+#include <unity-protocol.h>
+
+#include "MoviePreview.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class MoviePreview::Impl
+{
+public:
+  Impl(MoviePreview* owner, glib::Object<GObject> const& proto_obj);
+
+  void SetupGetters();
+  std::string get_year() const { return year_; };
+  float get_rating() const { return rating_; };
+  unsigned int get_num_ratings() const { return num_ratings_; };
+
+  MoviePreview* owner_;
+
+  std::string year_;
+  float rating_;
+  unsigned int num_ratings_;
+};
+
+MoviePreview::Impl::Impl(MoviePreview* owner, 
+                         glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+{
+  auto preview = glib::object_cast<UnityProtocolMoviePreview>(proto_obj);
+  const gchar* s;
+  s = unity_protocol_movie_preview_get_year(preview);
+  if (s) year_ = s;
+  rating_ = unity_protocol_movie_preview_get_rating(preview);
+  num_ratings_ = unity_protocol_movie_preview_get_num_ratings(preview);
+
+  SetupGetters();
+}
+
+void MoviePreview::Impl::SetupGetters()
+{
+  owner_->year.SetGetterFunction(
+      sigc::mem_fun(this, &MoviePreview::Impl::get_year));
+  owner_->rating.SetGetterFunction(
+      sigc::mem_fun(this, &MoviePreview::Impl::get_rating));
+  owner_->num_ratings.SetGetterFunction(
+      sigc::mem_fun(this, &MoviePreview::Impl::get_num_ratings));
+}
+
+MoviePreview::MoviePreview(unity::glib::Object<GObject> const& proto_obj)
+  : Preview(proto_obj)
+  , pimpl(new Impl(this, proto_obj))
+{
+}
+
+MoviePreview::~MoviePreview()
+{
+}
+
+}
+}

=== added file 'UnityCore/MoviePreview.h'
--- UnityCore/MoviePreview.h	1970-01-01 00:00:00 +0000
+++ UnityCore/MoviePreview.h	2012-07-17 13:45:25 +0000
@@ -0,0 +1,55 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
+ */
+
+#ifndef UNITY_MOVIE_PREVIEW_H
+#define UNITY_MOVIE_PREVIEW_H
+
+#include <memory>
+
+#include <sigc++/trackable.h>
+
+#include "Preview.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class MoviePreview : public Preview
+{
+public:
+  typedef std::shared_ptr<MoviePreview> Ptr;
+  
+  MoviePreview(unity::glib::Object<GObject> const& proto_obj);
+  ~MoviePreview();
+
+  nux::RWProperty<std::string> year;
+  nux::RWProperty<float> rating;
+  nux::RWProperty<unsigned int> num_ratings;
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+}
+}
+
+#endif

=== renamed file 'UnityCore/MusicPreviews.cpp' => 'UnityCore/MusicPreview.cpp'
--- UnityCore/MusicPreviews.cpp	2011-08-09 12:47:25 +0000
+++ UnityCore/MusicPreview.cpp	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,74 +15,98 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
-#include "MusicPreviews.h"
+#include <unity-protocol.h>
+
+#include "MusicPreview.h"
+#include "Tracks.h"
 
 namespace unity
 {
 namespace dash
 {
 
-TrackPreview::TrackPreview(Preview::Properties& properties)
-  : number(PropertyToUnsignedInt(properties, "number"))
-  , title(PropertyToString(properties, "title"))
-  , artist(PropertyToString(properties, "artist"))
-  , album(PropertyToString(properties, "album"))
-  , length(PropertyToUnsignedInt(properties, "length"))
-  , genres(PropertyToStringVector(properties, "genres"))
-  , album_cover(PropertyToString(properties, "album-cover"))
-  , primary_action_name(PropertyToString(properties, "primary-action-name"))
-  , primary_action_icon_hint(PropertyToString(properties, "primary-action-icon-hint"))
-  , primary_action_uri(PropertyToString(properties, "primary-action-uri"))
-  , play_action_uri(PropertyToString(properties, "play-action-uri"))
-  , pause_action_uri(PropertyToString(properties, "pause-action-uri"))
-{
- renderer_name = "preview-track";
-}
-
-AlbumPreview::AlbumPreview(Preview::Properties& properties)
-  : name(PropertyToString(properties, "name"))
-  , artist(PropertyToString(properties, "artist"))
-  , year(PropertyToString(properties, "year"))
-  , genres(PropertyToStringVector(properties, "genres"))
-  , album_cover(PropertyToString(properties, "album-cover"))
-  , primary_action_name(PropertyToString(properties, "primary-action-name"))
-  , primary_action_icon_hint(PropertyToString(properties, "primary-action-icon-hint"))
-  , primary_action_uri(PropertyToString(properties, "primary-action-uri"))
-{
-  renderer_name = "preview-album";
-  LoadTracks(properties);
-}
-
-void AlbumPreview::LoadTracks(Properties& properties)
-{
-  GVariantIter *iter = NULL;
-  unsigned int track_number = 0;
-  char* track_title;
-  unsigned int track_length = 0;
-  char* track_play_uri;
-  char* track_pause_uri;
-
-  if (properties.find("tracks") == properties.end())
-    return;
-
-  g_variant_get(properties["tracks"], "(ususs)", &iter);
-
-  while (g_variant_iter_loop(iter, "ususs",
-                             &track_number,
-                             &track_title,
-                             &track_length,
-                             &track_play_uri,
-                             &track_pause_uri))
+class MusicPreview::Impl
+{
+public:
+  Impl(MusicPreview* owner, glib::Object<GObject> const& proto_obj);
+
+  void PlayUri(std::string const& uri) const;
+  void PauseUri(std::string const& uri) const;
+
+  MusicPreview* owner_;
+
+  glib::Object<UnityProtocolMusicPreview> raw_preview_;
+  Tracks::Ptr tracks_model;
+};
+
+MusicPreview::Impl::Impl(MusicPreview* owner,
+                         glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+  , tracks_model(new Tracks())
+{
+  const gchar* s;
+  raw_preview_ = glib::object_cast<UnityProtocolMusicPreview>(proto_obj);
+
+  s = unity_protocol_music_preview_get_track_data_swarm_name(raw_preview_);
+  std::string swarm_name(s != NULL ? s : "");
+  s = unity_protocol_music_preview_get_track_data_address(raw_preview_);
+  std::string peer_address(s != NULL ? s : "");
+
+  // TODO: we're not using private connection yet
+  if (!swarm_name.empty())
   {
-    Track track(track_number, track_title, track_length, track_play_uri, track_pause_uri);
-    tracks.push_back(track);
-
-    length += track_length;
+    tracks_model->swarm_name = swarm_name;
   }
-
-  g_variant_iter_free(iter);
+}
+
+void MusicPreview::Impl::PlayUri(std::string const& uri) const
+{
+  UnityProtocolPreview *preview = UNITY_PROTOCOL_PREVIEW(raw_preview_.RawPtr());
+
+  unity_protocol_preview_begin_updates(preview);
+  unity_protocol_music_preview_play_uri(raw_preview_, uri.c_str());
+  glib::Variant properties(unity_protocol_preview_end_updates(preview),
+                           glib::StealRef());
+  owner_->Update(properties);
+}
+
+void MusicPreview::Impl::PauseUri(std::string const& uri) const
+{
+  UnityProtocolPreview *preview = UNITY_PROTOCOL_PREVIEW(raw_preview_.RawPtr());
+
+  unity_protocol_preview_begin_updates(preview);
+  unity_protocol_music_preview_pause_uri(raw_preview_, uri.c_str());
+  glib::Variant properties(unity_protocol_preview_end_updates(preview),
+                           glib::StealRef());
+  owner_->Update(properties);
+}
+
+MusicPreview::MusicPreview(unity::glib::Object<GObject> const& proto_obj)
+  : Preview(proto_obj)
+  , pimpl(new Impl(this, proto_obj))
+{
+}
+
+MusicPreview::~MusicPreview()
+{
+}
+
+Tracks::Ptr MusicPreview::GetTracksModel() const
+{
+  return pimpl->tracks_model;
+}
+
+void MusicPreview::PlayUri(std::string const& uri) const
+{
+  pimpl->PlayUri(uri);
+}
+
+void MusicPreview::PauseUri(std::string const& uri) const
+{
+  pimpl->PauseUri(uri);
 }
 
 }

=== renamed file 'UnityCore/MusicPreviews.h' => 'UnityCore/MusicPreview.h'
--- UnityCore/MusicPreviews.h	2011-08-02 22:50:10 +0000
+++ UnityCore/MusicPreview.h	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,87 +15,42 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
-#ifndef UNITY_MUSIC_PREVIEWS_H
-#define UNITY_MUSIC_PREVIEWS_H
+#ifndef UNITY_MUSIC_PREVIEW_H
+#define UNITY_MUSIC_PREVIEW_H
 
 #include <memory>
 
 #include <sigc++/trackable.h>
 
 #include "Preview.h"
+#include "Tracks.h"
 
 namespace unity
 {
 namespace dash
 {
 
-class TrackPreview : public Preview
-{
-public:
-  typedef std::shared_ptr<TrackPreview> Ptr;
-  typedef std::vector<std::string> Genres;
-
-  TrackPreview(Preview::Properties& properties);
-
-  unsigned int number;
-  std::string title;
-  std::string artist;
-  std::string album;
-  unsigned int length;
-  Genres genres;
-  std::string album_cover;
-  std::string primary_action_name;
-  std::string primary_action_icon_hint;
-  std::string primary_action_uri;
-  std::string play_action_uri;
-  std::string pause_action_uri;
-};
-
-class AlbumPreview : public Preview
-{
-public:
-  typedef std::shared_ptr<AlbumPreview> Ptr;
-  typedef std::vector<std::string> Genres;
-
-  struct Track
-  {
-  public:
-
-    Track(unsigned int number_, std::string title_, unsigned int length_,
-          std::string play_action_uri_, std::string pause_action_uri_)
-      : number(number_)
-      , title(title_)
-      , length(length_)
-      , play_action_uri(play_action_uri_)
-      , pause_action_uri(pause_action_uri_)
-    {}
-
-    unsigned int number;
-    std::string title;
-    unsigned int length;
-    std::string play_action_uri;
-    std::string pause_action_uri;
-  };
-  
-  typedef std::vector<Track> Tracks;
-
-  AlbumPreview(Preview::Properties& properties);
-
-  void LoadTracks(Properties& properties);
-
-  std::string name;
-  std::string artist;
-  std::string year;
-  unsigned int length;
-  Genres genres;
-  Tracks tracks;
-  std::string album_cover;
-  std::string primary_action_name;
-  std::string primary_action_icon_hint;
-  std::string primary_action_uri;
-};
+class MusicPreview : public Preview
+{
+public:
+  typedef std::shared_ptr<MusicPreview> Ptr;
+
+  MusicPreview(unity::glib::Object<GObject> const& proto_obj);
+  ~MusicPreview();
+
+  Tracks::Ptr GetTracksModel() const;
+
+  void PlayUri(std::string const& uri) const;
+  void PauseUri(std::string const& uri) const;
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
 }
 }
 

=== modified file 'UnityCore/Preview.cpp'
--- UnityCore/Preview.cpp	2011-08-09 12:47:25 +0000
+++ UnityCore/Preview.cpp	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,90 +15,245 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
+#include <NuxCore/Logger.h>
+#include <unity-protocol.h>
+
+#include "Lens.h"
 #include "Preview.h"
 
 #include "ApplicationPreview.h"
 #include "GenericPreview.h"
-#include "MusicPreviews.h"
+#include "MusicPreview.h"
+#include "MoviePreview.h"
+#include "SeriesPreview.h"
 
 namespace unity
 {
 namespace dash
 {
 
-Preview::Ptr Preview::PreviewForProperties(std::string const& renderer_name_,
-                                           Properties& properties)
-{
-  if (renderer_name_ == "preview-application")
-  {
-    return Preview::Ptr(new ApplicationPreview(properties));
-  }
-  else if (renderer_name_ == "preview-generic")
-  {
-    return Preview::Ptr(new GenericPreview(properties));
-  }
-  else if (renderer_name_ == "preview-track")
-  {
-    return Preview::Ptr(new TrackPreview(properties));
-  }
-  else if (renderer_name_ == "preview-album")
-  {
-    return Preview::Ptr(new AlbumPreview(properties));
-  }
-  else
-  {
-    return Preview::Ptr(new NoPreview());
-  }
+namespace
+{
+  nux::logging::Logger logger("unity.dash.preview");
+}
+
+Preview::Ptr Preview::PreviewForProtocolObject(glib::Object<GObject> const& proto_obj)
+{
+  if (!proto_obj || !UNITY_PROTOCOL_IS_PREVIEW(proto_obj.RawPtr()))
+  {
+    LOG_WARN(logger) << "Unable to create Preview object from " << proto_obj.RawPtr();
+    return nullptr;
+  }
+
+  std::string renderer_name(
+      unity_protocol_preview_get_renderer_name(
+        UNITY_PROTOCOL_PREVIEW(proto_obj.RawPtr())));
+
+  if (renderer_name == "preview-generic")
+  {
+    return Preview::Ptr(new GenericPreview(proto_obj));
+  }
+  else if (renderer_name == "preview-application")
+  {
+    return Preview::Ptr(new ApplicationPreview(proto_obj));
+  }
+  else if (renderer_name == "preview-music")
+  {
+    return Preview::Ptr(new MusicPreview(proto_obj));
+  }
+  else if (renderer_name == "preview-movie")
+  {
+    return Preview::Ptr(new MoviePreview(proto_obj));
+  }
+  else if (renderer_name == "preview-series")
+  {
+    return Preview::Ptr(new SeriesPreview(proto_obj));
+  }
+  else
+  {
+    LOG_WARN(logger) << "Unable to create Preview for renderer: " << renderer_name;
+  }
+
+  return nullptr;
+}
+
+Preview::Ptr Preview::PreviewForVariant(glib::Variant &properties)
+{
+  glib::Object<UnityProtocolPreview> preview(unity_protocol_preview_parse(properties));
+  if (!preview)
+  {
+    LOG_WARN(logger) << "Unable to create Preview object for variant type: " << g_variant_get_type_string(properties);
+    return nullptr;
+  }
+
+  auto proto_obj = unity::glib::object_cast<GObject>(preview);
+  return PreviewForProtocolObject(proto_obj);
+}
+
+unity::glib::Object<GIcon> Preview::IconForString(std::string const& icon_hint)
+{
+  glib::Error error;
+  glib::Object<GIcon> icon(g_icon_new_for_string(icon_hint.c_str(), &error));
+
+  if (error)
+  {
+    LOG_WARN(logger) << "Unable to instantiate icon: " << icon_hint;
+  }
+
+  return icon;
+}
+
+class Preview::Impl
+{
+public:
+  Impl(Preview* owner, glib::Object<GObject> const& proto_obj);
+
+  void SetupGetters();
+  std::string get_renderer_name() const { return renderer_name_; };
+  std::string get_title() const { return title_; };
+  std::string get_subtitle() const { return subtitle_; };
+  std::string get_description() const { return description_; };
+  unity::glib::Object<GIcon> get_image() const { return image_; };
+  ActionPtrList get_actions() const { return actions_list_; };
+  InfoHintPtrList get_info_hints() const { return info_hint_list_; };
+
+  Lens* get_parent_lens() const { return parent_lens_; };
+  bool set_parent_lens(Lens* lens)
+  {
+    parent_lens_ = lens;
+    return false; // TODO: do we need the notifications here?
+  };
+
+  Preview* owner_;
+
+  std::string renderer_name_;
+  std::string title_;
+  std::string subtitle_;
+  std::string description_;
+  unity::glib::Object<GIcon> image_;
+  ActionPtrList actions_list_;
+  InfoHintPtrList info_hint_list_;
+  Lens* parent_lens_;
+};
+
+Preview::Impl::Impl(Preview* owner, glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+  , parent_lens_(nullptr)
+{
+  if (!proto_obj)
+  {
+    LOG_WARN(logger) << "Passed nullptr to Preview constructor";
+  }
+  else if (UNITY_PROTOCOL_IS_PREVIEW(proto_obj.RawPtr()))
+  {
+    auto preview = glib::object_cast<UnityProtocolPreview>(proto_obj);
+    const gchar *s;
+    // renderer is guaranteed to be non-NULL, if it is it's a bug in proto lib
+    renderer_name_ = unity_protocol_preview_get_renderer_name(preview);
+    s = unity_protocol_preview_get_title(preview);
+    if (s) title_ = s;
+    s = unity_protocol_preview_get_subtitle(preview);
+    if (s) subtitle_ = s;
+    s = unity_protocol_preview_get_description(preview);
+    if (s) description_ = s;
+    glib::Object<GIcon> icon(unity_protocol_preview_get_thumbnail(preview),
+                             unity::glib::AddRef());
+    image_ = icon;
+
+    int actions_len;
+    auto actions = unity_protocol_preview_get_actions(preview, &actions_len);
+    for (int i = 0; i < actions_len; i++)
+    {
+      UnityProtocolPreviewActionRaw *raw_action = &actions[i];
+      actions_list_.push_back(std::make_shared<Action>(
+            raw_action->id, raw_action->display_name,
+            raw_action->icon_hint,
+            static_cast<LayoutHint>(raw_action->layout_hint)));
+    }
+    
+    int info_hints_len;
+    auto info_hints = unity_protocol_preview_get_info_hints(preview, &info_hints_len);
+    for (int i = 0; i < info_hints_len; i++)
+    {
+      UnityProtocolInfoHintRaw *raw_hint = &info_hints[i];
+      info_hint_list_.push_back(std::make_shared<InfoHint>(
+            raw_hint->id, raw_hint->display_name, raw_hint->icon_hint,
+            raw_hint->value));
+    }
+  }
+  else
+  {
+    LOG_WARN(logger) << "Object passed to Preview constructor isn't UnityProtocolPreview";
+  }
+
+  SetupGetters();
+}
+
+void Preview::Impl::SetupGetters()
+{
+  owner_->renderer_name.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_renderer_name));
+  owner_->title.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_title));
+  owner_->subtitle.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_subtitle));
+  owner_->description.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_description));
+  owner_->image.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_image));
+
+  owner_->parent_lens.SetGetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::get_parent_lens));
+  owner_->parent_lens.SetSetterFunction(
+      sigc::mem_fun(this, &Preview::Impl::set_parent_lens));
+}
+
+Preview::Preview(glib::Object<GObject> const& proto_obj)
+  : pimpl(new Impl(this, proto_obj))
+{
 }
 
 Preview::~Preview()
-{}
-
-unsigned int Preview::PropertyToUnsignedInt (Properties& properties, const char* key)
-{
-  return g_variant_get_uint32(properties[key]);
-}
-
-std::string Preview::PropertyToString(Properties& properties, const char *key)
-{
-  if (properties.find(key) == properties.end())
-   return "";
-  return g_variant_get_string(properties[key], NULL);
-}
-
-std::vector<std::string> Preview::PropertyToStringVector(Properties& properties, const char *key)
-{
-  GVariantIter* iter = NULL;
-  char* value = NULL;
-  std::vector<std::string> property;
-
-  if (properties.find(key) == properties.end())
-    return property;
-
-  g_variant_get(properties[key], "as", &iter);
-
-  while (g_variant_iter_loop(iter, "s", &value))
-    property.push_back(value);
-
-  g_variant_iter_free(iter);
-
-  return property;
-}
-
-float Preview::PropertyToFloat(Properties& properties, const char* key)
-{
-  if (properties.find(key) == properties.end())
-    return 0.0f;
-
-  return (float)g_variant_get_double(properties[key]);
-}
-
-NoPreview::NoPreview()
-{
-  renderer_name = "preview-none";
-}
-
-}
-}
+{
+}
+
+Preview::ActionPtrList Preview::GetActions() const
+{
+  return pimpl->get_actions();
+}
+
+Preview::InfoHintPtrList Preview::GetInfoHints() const
+{
+  return pimpl->get_info_hints();
+}
+
+void Preview::Update(glib::Variant const& properties,
+                     glib::DBusProxy::ReplyCallback reply_callback) const
+{
+  if (pimpl->parent_lens_)
+  {
+    pimpl->parent_lens_->SignalPreview(preview_uri, properties, reply_callback);
+  }
+  else
+  {
+    LOG_WARN(logger) << "Unable to update Preview, parent_lens wasn't set!";
+  }
+}
+
+void Preview::PerformAction(std::string const& id) const
+{
+  if (pimpl->parent_lens_)
+  {
+    pimpl->parent_lens_->ActivatePreviewAction(id, preview_uri);
+  }
+  else
+  {
+    LOG_WARN(logger) << "Unable to perform action, parent_lens wasn't set!";
+  }
+}
+
+} // namespace dash
+} // namespace unity

=== modified file 'UnityCore/Preview.h'
--- UnityCore/Preview.h	2012-03-14 06:24:18 +0000
+++ UnityCore/Preview.h	2012-07-17 13:45:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
 #ifndef UNITY_PREVIEW_H
@@ -25,9 +26,13 @@
 #include <string>
 #include <vector>
 
+#include <glib.h>
+#include <gio/gio.h>
 #include <sigc++/trackable.h>
+#include <NuxCore/Property.h>
 
-#include <glib.h>
+#include "GLibWrapper.h"
+#include "GLibDBusProxy.h"
 #include "Variant.h"
 
 namespace unity
@@ -35,29 +40,90 @@
 namespace dash
 {
 
+class Lens;
+
+enum LayoutHint
+{
+  NONE,
+  LEFT,
+  RIGHT,
+  TOP,
+  BOTTOM
+};
+
 class Preview : public sigc::trackable
 {
 public:
+  struct Action
+  {
+    std::string id;
+    std::string display_name;
+    std::string icon_hint;
+    LayoutHint layout_hint;
+    // TODO: there's also a HashTable here (although unused atm)
+
+    Action() {};
+    Action(const gchar* id_, const gchar* display_name_,
+           const gchar* icon_hint_, LayoutHint layout_hint_)
+      : id(id_ != NULL ? id_ : "")
+      , display_name(display_name_ != NULL ? display_name_ : "")
+      , icon_hint(icon_hint_ != NULL ? icon_hint_ : "")
+      , layout_hint(layout_hint_) {};
+  };
+
+  struct InfoHint
+  {
+    std::string id;
+    std::string display_name;
+    std::string icon_hint;
+    unity::glib::Variant value;
+
+    InfoHint() {};
+    InfoHint(const gchar* id_, const gchar* display_name_, 
+             const gchar* icon_hint_, GVariant* value_)
+      : id(id_ != NULL ? id_ : "")
+      , display_name(display_name_ != NULL ? display_name_ : "")
+      , icon_hint(icon_hint_ != NULL ? icon_hint_ : "")
+      , value(value_) {};
+  };
+
   typedef std::shared_ptr<Preview> Ptr;
-  typedef std::map<std::string, unity::glib::Variant> Properties;
+  typedef std::shared_ptr<Action> ActionPtr;
+  typedef std::shared_ptr<InfoHint> InfoHintPtr;
+  typedef std::vector<ActionPtr> ActionPtrList;
+  typedef std::vector<InfoHintPtr> InfoHintPtrList;
 
   virtual ~Preview();
 
-  static Preview::Ptr PreviewForProperties(std::string const& renderer_name, Properties& properties);
-
-  std::string renderer_name;
+  static Preview::Ptr PreviewForVariant(glib::Variant& properties);
+  static Preview::Ptr PreviewForProtocolObject(glib::Object<GObject> const& proto_obj);
+
+  nux::ROProperty<std::string> renderer_name;
+  nux::ROProperty<std::string> title;
+  nux::ROProperty<std::string> subtitle;
+  nux::ROProperty<std::string> description;
+  nux::ROProperty<unity::glib::Object<GIcon>> image;
+
+  // can't use Lens::Ptr to avoid circular dependency
+  nux::RWProperty<Lens*> parent_lens;
+  nux::Property<std::string> preview_uri;
+
+  ActionPtrList GetActions() const;
+  InfoHintPtrList GetInfoHints() const;
+
+  void PerformAction(std::string const& id) const;
 
 protected:
-  unsigned int PropertyToUnsignedInt (Properties& properties, const char* key);
-  std::string PropertyToString(Properties& properties, const char *key);
-  std::vector<std::string> PropertyToStringVector(Properties& properties, const char *key);
-  float PropertyToFloat(Properties& properties, const char* key);
-};
+  // this should be UnityProtocolPreview, but we want to keep the usage
+  // of libunity-protocol-private private to unity-core
+  Preview(glib::Object<GObject> const& proto_obj);
+  void Update(glib::Variant const& properties,
+              glib::DBusProxy::ReplyCallback reply_callback = nullptr) const;
+  static glib::Object<GIcon> IconForString(std::string const& icon_hint);
 
-class NoPreview : public Preview
-{
-public:
-  NoPreview();
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
 };
 
 }

=== added file 'UnityCore/SeriesPreview.cpp'
--- UnityCore/SeriesPreview.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/SeriesPreview.cpp	2012-07-17 13:45:25 +0000
@@ -0,0 +1,149 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
+ */
+
+#include <unity-protocol.h>
+
+#include "SeriesPreview.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class SeriesPreview::Impl
+{
+public:
+  Impl(SeriesPreview* owner, glib::Object<GObject> const& proto_obj);
+
+  void SetupGetters();
+  void selected_item_reply(GVariant* reply);
+  int get_selected_item_index() const { return selected_item_index_; };
+  bool set_selected_item_index(int index);
+  SeriesItemPtrList get_items() const { return items_list_; };
+  Preview::Ptr get_child_preview() const
+  {
+    if (!child_preview_->parent_lens)
+      child_preview_->parent_lens = owner_->parent_lens();
+    if (child_preview_->preview_uri().empty())
+      child_preview_->preview_uri = owner_->preview_uri();
+    return child_preview_;
+  };
+
+  SeriesPreview* owner_;
+  glib::Object<UnityProtocolSeriesPreview> raw_preview_;
+
+  Preview::Ptr child_preview_;
+  SeriesItemPtrList items_list_;
+  int selected_item_index_;
+};
+
+SeriesPreview::Impl::Impl(SeriesPreview* owner,
+                          glib::Object<GObject> const& proto_obj)
+  : owner_(owner)
+  , selected_item_index_(-1)
+{
+  raw_preview_ = glib::object_cast<UnityProtocolSeriesPreview>(proto_obj);
+
+  int items_len;
+  auto items = unity_protocol_series_preview_get_items(raw_preview_,
+                                                       &items_len);
+  for (int i = 0; i < items_len; i++)
+  {
+    UnityProtocolSeriesItemRaw* raw_item = &items[i];
+    items_list_.push_back(std::make_shared<SeriesItem>(
+          raw_item->uri, raw_item->title, raw_item->icon_hint));
+  }
+
+  glib::Object<UnityProtocolPreview> child_preview(
+      unity_protocol_series_preview_get_child_preview(raw_preview_),
+      glib::AddRef());
+  child_preview_ = Preview::PreviewForProtocolObject(glib::object_cast<GObject>(child_preview));
+
+  selected_item_index_ =
+    unity_protocol_series_preview_get_selected_item(raw_preview_);
+
+  SetupGetters();
+}
+
+void SeriesPreview::Impl::SetupGetters()
+{
+  owner_->selected_item_index.SetGetterFunction(
+      sigc::mem_fun(this, &SeriesPreview::Impl::get_selected_item_index));
+  owner_->selected_item_index.SetSetterFunction(
+      sigc::mem_fun(this, &SeriesPreview::Impl::set_selected_item_index));
+}
+
+bool SeriesPreview::Impl::set_selected_item_index(int index)
+{
+  if (index != selected_item_index_)
+  {
+    selected_item_index_ = index;
+    
+    UnityProtocolPreview *preview = UNITY_PROTOCOL_PREVIEW(raw_preview_.RawPtr());
+    unity_protocol_preview_begin_updates(preview);
+    unity_protocol_series_preview_set_selected_item(raw_preview_, index);
+    glib::Variant properties(unity_protocol_preview_end_updates(preview),
+                             glib::StealRef());
+    owner_->Update(properties, sigc::mem_fun(this, &SeriesPreview::Impl::selected_item_reply));
+    return true;
+  }
+
+  return false;
+}
+
+void SeriesPreview::Impl::selected_item_reply(GVariant *reply)
+{
+  glib::Variant dict(reply);
+  glib::HintsMap hints;
+  dict.ASVToHints(hints);
+
+  auto iter = hints.find("preview");
+  if (iter != hints.end())
+  {
+    Preview::Ptr new_child = Preview::PreviewForVariant(iter->second);
+    new_child->parent_lens = owner_->parent_lens();
+    new_child->preview_uri = owner_->preview_uri(); // FIXME: really?
+    child_preview_ = new_child;
+    owner_->child_preview_changed.emit(new_child);
+  }
+}
+
+SeriesPreview::SeriesPreview(unity::glib::Object<GObject> const& proto_obj)
+  : Preview(proto_obj)
+  , pimpl(new Impl(this, proto_obj))
+{
+}
+
+SeriesPreview::~SeriesPreview()
+{
+}
+
+Preview::Ptr SeriesPreview::GetChildPreview() const
+{
+  return pimpl->get_child_preview();
+}
+
+SeriesPreview::SeriesItemPtrList SeriesPreview::GetItems() const
+{
+  return pimpl->get_items();
+}
+
+}
+}

=== added file 'UnityCore/SeriesPreview.h'
--- UnityCore/SeriesPreview.h	1970-01-01 00:00:00 +0000
+++ UnityCore/SeriesPreview.h	2012-07-17 13:45:25 +0000
@@ -0,0 +1,73 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Michal Hruby <[e-mail]>
+ */
+
+#ifndef UNITY_SERIES_PREVIEW_H
+#define UNITY_SERIES_PREVIEW_H
+
+#include <memory>
+
+#include <sigc++/trackable.h>
+
+#include "Preview.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class SeriesPreview : public Preview
+{
+public:
+  struct SeriesItem
+  {
+    std::string uri;
+    std::string title;
+    std::string icon_hint;
+
+    SeriesItem() {};
+    SeriesItem(const gchar* uri_, const gchar* title_, const gchar* icon_hint_)
+      : uri(uri_ != NULL ? uri_ : "")
+      , title(title_ != NULL ? title_ : "")
+      , icon_hint(icon_hint_ != NULL ? icon_hint_ : "") {};
+  };
+
+  typedef std::shared_ptr<SeriesPreview> Ptr;
+  typedef std::shared_ptr<SeriesItem> SeriesItemPtr;
+  typedef std::vector<SeriesItemPtr> SeriesItemPtrList;
+  
+  SeriesPreview(unity::glib::Object<GObject> const& proto_obj);
+  ~SeriesPreview();
+
+  nux::RWProperty<int> selected_item_index;
+
+  SeriesItemPtrList GetItems() const;
+  Preview::Ptr GetChildPreview() const;
+
+  sigc::signal<void, Preview::Ptr const&> child_preview_changed;
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+}
+}
+
+#endif

=== added file 'UnityCore/Track.cpp'
--- UnityCore/Track.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/Track.cpp	2012-07-17 13:45:25 +0000
@@ -0,0 +1,66 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ */
+
+#include "Track.h"
+#include <sigc++/bind.h>
+
+namespace unity
+{
+namespace dash
+{
+
+Track::Track(DeeModel* model,
+             DeeModelIter* iter,
+             DeeModelTag* renderer_tag)
+  : RowAdaptorBase(model, iter, renderer_tag)
+{
+  SetupGetters();
+}
+
+Track::Track(Track const& other)
+  : RowAdaptorBase(other)
+{
+  SetupGetters();
+}
+
+Track& Track::operator=(Track const& other)
+{
+  RowAdaptorBase::operator=(other);
+  SetupGetters();
+  return *this;
+}
+
+PlayState Track::GetPlayState(int position)
+{
+  unsigned state = GetUIntAt(position);
+  return static_cast<PlayState>(state);
+}
+
+void Track::SetupGetters()
+{
+  uri.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 0));
+  track_number.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetIntAt), 1));
+  title.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetStringAt), 2));
+  length.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetUIntAt), 3));
+  play_state.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &Track::GetPlayState), 4));
+  progress.SetGetterFunction(sigc::bind(sigc::mem_fun(this, &RowAdaptorBase::GetFloatAt), 5));
+}
+
+}
+}

=== added file 'UnityCore/Track.h'
--- UnityCore/Track.h	1970-01-01 00:00:00 +0000
+++ UnityCore/Track.h	2012-07-17 13:45:25 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ */
+
+#ifndef UNITY_TRACK_H
+#define UNITY_TRACK_H
+
+#include <NuxCore/Property.h>
+
+#include "ModelRowAdaptor.h"
+
+namespace unity
+{
+namespace dash
+{
+
+enum PlayState
+{
+  STOPPED,
+  PLAYING,
+  PAUSED
+};
+
+/* This class represents a DeeModelIter for a TracksModel
+ * It's slightly chunky, but that is because it's optimized to be stack-allocated
+ * as it is not expected to be kept by the views, rather views can easily attach
+ * a "renderer" to the iter, so when the changed or removed signals are called,
+ * the view can easily find which widget/view belongs to this iter.
+ */
+class Track : public RowAdaptorBase
+{
+public:
+  Track(DeeModel* model, DeeModelIter* iter, DeeModelTag* tag);
+
+  Track(Track const& other);
+  Track& operator=(Track const& other);
+
+  nux::ROProperty<std::string> uri;
+  nux::ROProperty<int> track_number;
+  nux::ROProperty<std::string> title;
+  nux::ROProperty<unsigned> length;
+  nux::ROProperty<PlayState> play_state;
+  nux::ROProperty<float> progress;
+
+private:
+  void SetupGetters();
+  PlayState GetPlayState(int position);
+};
+
+}
+}
+
+#endif

=== added file 'UnityCore/Tracks.cpp'
--- UnityCore/Tracks.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/Tracks.cpp	2012-07-17 13:45:25 +0000
@@ -0,0 +1,58 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ */
+
+#include "Tracks.h"
+
+namespace unity
+{
+namespace dash
+{
+
+Tracks::Tracks()
+{
+  row_added.connect(sigc::mem_fun(this, &Tracks::OnRowAdded));
+  row_changed.connect(sigc::mem_fun(this, &Tracks::OnRowChanged));
+  row_removed.connect(sigc::mem_fun(this, &Tracks::OnRowRemoved));
+}
+
+Tracks::Tracks(ModelType model_type)
+  : Model<Track>::Model(model_type)
+{
+  row_added.connect(sigc::mem_fun(this, &Tracks::OnRowAdded));
+  row_changed.connect(sigc::mem_fun(this, &Tracks::OnRowChanged));
+  row_removed.connect(sigc::mem_fun(this, &Tracks::OnRowRemoved));
+}
+
+void Tracks::OnRowAdded(Track& result)
+{
+  track_added.emit(result);
+}
+
+void Tracks::OnRowChanged(Track& result)
+{
+  track_changed.emit(result);
+}
+
+void Tracks::OnRowRemoved(Track& result)
+{
+  track_removed.emit(result);
+}
+
+}
+}

=== added file 'UnityCore/Tracks.h'
--- UnityCore/Tracks.h	1970-01-01 00:00:00 +0000
+++ UnityCore/Tracks.h	2012-07-17 13:45:25 +0000
@@ -0,0 +1,54 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ */
+
+#ifndef UNITY_TRACKS_H
+#define UNITY_TRACKS_H
+
+#include <memory>
+
+#include "Model.h"
+#include "Track.h"
+
+namespace unity
+{
+namespace dash
+{
+
+class Tracks : public Model<Track>
+{
+public:
+  typedef std::shared_ptr<Tracks> Ptr;
+
+  Tracks();
+  Tracks(ModelType model_type);
+
+  sigc::signal<void, Track const&> track_added;
+  sigc::signal<void, Track const&> track_changed;
+  sigc::signal<void, Track const&> track_removed;
+
+private:
+  void OnRowAdded(Track& result);
+  void OnRowChanged(Track& result);
+  void OnRowRemoved(Track& result);
+};
+
+}
+}
+
+#endif

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-07-13 11:08:50 +0000
+++ tests/CMakeLists.txt	2012-07-17 13:45:25 +0000
@@ -144,6 +144,7 @@
                  test_favorite_store_private.cpp
                  test_home_lens.cpp
                  test_launcher_entry_remote.cpp
+                 test_previews.cpp
                  test_shortcut_model.cpp
                  test_shortcut_private.cpp
                  test_introspection.cpp

=== modified file 'tests/test_lens.cpp'
--- tests/test_lens.cpp	2012-07-16 11:03:32 +0000
+++ tests/test_lens.cpp	2012-07-17 13:45:25 +0000
@@ -6,7 +6,9 @@
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Lens.h>
 #include <UnityCore/MultiRangeFilter.h>
-#include <UnityCore/MusicPreviews.h>
+#include <UnityCore/Preview.h>
+#include <UnityCore/SeriesPreview.h>
+#include <UnityCore/Variant.h>
 #include <UnityCore/RadioOptionFilter.h>
 #include <UnityCore/RatingsFilter.h>
 
@@ -52,7 +54,7 @@
   void WaitForConnected()
   {
     bool timeout_reached = false;
-    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached);
+    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached, 2000);
 
     while (!lens_->connected && !timeout_reached)
     {
@@ -68,7 +70,7 @@
   void WaitForModel(Model<Adaptor>* model, unsigned int n_rows)
   {
     bool timeout_reached = false;
-    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached);
+    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached, 2000);
     
     while (model->count != n_rows && !timeout_reached)
     {
@@ -209,37 +211,102 @@
 
 TEST_F(TestLens, TestPreview)
 {
-  // FIXME: fix up when unity-core supports current preview protocol
-  /*
   std::string uri = PopulateAndGetFirstResultURI();
   bool previewed = false;
 
   auto preview_cb = [&previewed, &uri] (std::string const& uri_,
-                                  Preview::Ptr preview)
-  {
-    EXPECT_EQ(uri, uri_);
-    EXPECT_EQ(preview->renderer_name, "preview-generic");
-
-    TrackPreview::Ptr track_preview = std::static_pointer_cast<TrackPreview>(preview);
-    EXPECT_EQ(track_preview->number, (unsigned int)1);
-    EXPECT_EQ(track_preview->title, "Animus Vox");
-    EXPECT_EQ(track_preview->artist, "The Glitch Mob");
-    EXPECT_EQ(track_preview->album, "Drink The Sea");
-    EXPECT_EQ(track_preview->length, (unsigned int)404);
-    EXPECT_EQ(track_preview->album_cover, "file://music/the/track");
-    EXPECT_EQ(track_preview->primary_action_name, "Play");
-    EXPECT_EQ(track_preview->primary_action_icon_hint, "");
-    EXPECT_EQ(track_preview->primary_action_uri, "play://music/the/track");
-    EXPECT_EQ(track_preview->play_action_uri, "preview://music/the/track");
-    EXPECT_EQ(track_preview->pause_action_uri, "pause://music/the/track");
-    EXPECT_EQ(track_preview->genres.size(), (unsigned int)1);
-    previewed = true;
-  };
-  lens_->preview_ready.connect(preview_cb);
-
-  lens_->Preview(uri);
-  Utils::WaitUntil(previewed);
-  */
+                                        Preview::Ptr const& preview)
+  {
+    EXPECT_EQ(uri, uri_);
+    EXPECT_EQ(preview->renderer_name, "preview-series");
+
+    auto series = std::dynamic_pointer_cast<SeriesPreview>(preview);
+    EXPECT_EQ(series->GetItems().size(), (unsigned)4);
+    EXPECT_EQ(series->selected_item_index, 2);
+
+    auto child = series->GetChildPreview();
+    EXPECT_EQ(child->title, "A preview");
+    previewed = true;
+  };
+
+  lens_->preview_ready.connect(preview_cb);
+
+  lens_->Preview(uri);
+  Utils::WaitUntil(previewed);
+}
+
+TEST_F(TestLens, TestPreviewAction)
+{
+  std::string uri = PopulateAndGetFirstResultURI();
+  bool previewed = false;
+  Preview::Ptr preview;
+
+  auto preview_cb = [&previewed, &uri, &preview]
+                                        (std::string const& uri_,
+                                         Preview::Ptr const& preview_)
+  {
+    EXPECT_EQ(uri, uri_);
+    EXPECT_EQ(preview_->renderer_name, "preview-series");
+
+    preview = preview_;
+    previewed = true;
+  };
+
+  lens_->preview_ready.connect(preview_cb);
+  lens_->Preview(uri);
+
+  Utils::WaitUntil(previewed);
+
+  bool action_executed = false;
+  auto activated_cb = [&action_executed] (std::string const& uri,
+                                          HandledType handled_type,
+                                          Lens::Hints const& hints)
+  {
+    EXPECT_EQ(handled_type, HandledType::SHOW_DASH);
+    action_executed = true;
+  };
+
+  lens_->activated.connect(activated_cb);
+  EXPECT_GT(preview->GetActions().size(), (unsigned)0);
+  auto action = preview->GetActions()[0];
+  preview->PerformAction(action->id);
+
+  Utils::WaitUntil(action_executed);
+}
+
+TEST_F(TestLens, TestPreviewSignal)
+{
+  std::string uri = PopulateAndGetFirstResultURI();
+  bool previewed = false;
+  SeriesPreview::Ptr series_preview;
+
+  auto preview_cb = [&previewed, &uri, &series_preview]
+                                        (std::string const& uri_,
+                                         Preview::Ptr const& preview)
+  {
+    EXPECT_EQ(uri, uri_);
+    EXPECT_EQ(preview->renderer_name, "preview-series");
+
+    series_preview = std::dynamic_pointer_cast<SeriesPreview>(preview);
+    previewed = true;
+  };
+
+  lens_->preview_ready.connect(preview_cb);
+  lens_->Preview(uri);
+
+  Utils::WaitUntil(previewed);
+
+  bool child_changed = false;
+  auto child_changed_cb = [&child_changed] (Preview::Ptr const& new_child)
+  {
+    EXPECT_EQ(new_child->title, "A preview");
+    child_changed = true;
+  };
+
+  series_preview->child_preview_changed.connect(child_changed_cb);
+  series_preview->selected_item_index = 1;
+
+  Utils::WaitUntil(child_changed);
 }
 
 TEST_F(TestLens, TestFilterSync)

=== added file 'tests/test_previews.cpp'
--- tests/test_previews.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_previews.cpp	2012-07-17 13:45:25 +0000
@@ -0,0 +1,262 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include <list>
+#include <algorithm>
+#include <gmock/gmock.h>
+#include <gio/gio.h>
+#include <UnityCore/Variant.h>
+#include <UnityCore/Preview.h>
+#include <UnityCore/ApplicationPreview.h>
+#include <UnityCore/MoviePreview.h>
+#include <UnityCore/MusicPreview.h>
+#include <UnityCore/SeriesPreview.h>
+#include <unity-protocol.h>
+
+using namespace std;
+using namespace testing;
+using namespace unity;
+using namespace unity::glib;
+using namespace unity::dash;
+
+namespace
+{
+
+bool IsVariant(Variant const& variant)
+{
+  return g_variant_get_type_string(variant) != NULL;
+}
+
+TEST(TestPreviews, DeserializeGeneric)
+{
+  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
+  unity_protocol_preview_set_title(proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(proto_obj, icon);
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr preview = Preview::PreviewForVariant(v);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-generic");
+  EXPECT_EQ(preview->title, "Title");
+  EXPECT_EQ(preview->subtitle, "Subtitle");
+  EXPECT_EQ(preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
+}
+
+TEST(TestPreviews, DeserializeGenericWithMeta)
+{
+  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
+  unity_protocol_preview_set_title(proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(proto_obj, icon);
+  unity_protocol_preview_add_action(proto_obj, "action1", "Action #1", NULL, 0);
+  unity_protocol_preview_add_action(proto_obj, "action2", "Action #2", NULL, 0);
+  unity_protocol_preview_add_info_hint(proto_obj, "hint1", "Hint 1", NULL, g_variant_new("i", 34));
+  unity_protocol_preview_add_info_hint(proto_obj, "hint2", "Hint 2", NULL, g_variant_new("s", "string hint"));
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr preview = Preview::PreviewForVariant(v);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-generic");
+  EXPECT_EQ(preview->title, "Title");
+  EXPECT_EQ(preview->subtitle, "Subtitle");
+  EXPECT_EQ(preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
+
+  auto actions = preview->GetActions();
+  auto info_hints = preview->GetInfoHints();
+
+  EXPECT_EQ(actions.size(), 2);
+
+  auto action1 = actions[0];
+  EXPECT_EQ(action1->id, "action1");
+  EXPECT_EQ(action1->display_name, "Action #1");
+  EXPECT_EQ(action1->icon_hint, "");
+  EXPECT_EQ(action1->layout_hint, 0);
+
+  auto action2 = actions[1];
+  EXPECT_EQ(action2->id, "action2");
+  EXPECT_EQ(action2->display_name, "Action #2");
+  EXPECT_EQ(action2->icon_hint, "");
+
+  EXPECT_EQ(info_hints.size(), 2);
+  auto hint1 = info_hints[0];
+  EXPECT_EQ(hint1->id, "hint1");
+  EXPECT_EQ(hint1->display_name, "Hint 1");
+  EXPECT_EQ(hint1->icon_hint, "");
+  EXPECT_EQ(hint1->value.GetInt(), 34);
+  auto hint2 = info_hints[1];
+  EXPECT_EQ(hint2->id, "hint2");
+  EXPECT_EQ(hint2->display_name, "Hint 2");
+  EXPECT_EQ(hint2->icon_hint, "");
+  EXPECT_EQ(hint2->value.GetString(), "string hint");
+}
+
+TEST(TestPreviews, DeserializeApplication)
+{
+  Object<GIcon> icon(g_icon_new_for_string("application", NULL));
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_application_preview_new()));
+  unity_protocol_preview_set_title(proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(proto_obj, icon);
+  auto app_proto_obj = glib::object_cast<UnityProtocolApplicationPreview>(proto_obj);
+  unity_protocol_application_preview_set_last_update(app_proto_obj, "2012/06/13");
+  unity_protocol_application_preview_set_copyright(app_proto_obj, "(c) Canonical");
+  unity_protocol_application_preview_set_license(app_proto_obj, "GPLv3");
+  unity_protocol_application_preview_set_app_icon(app_proto_obj, icon);
+  unity_protocol_application_preview_set_rating(app_proto_obj, 4.0);
+  unity_protocol_application_preview_set_num_ratings(app_proto_obj, 12);
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
+  ApplicationPreview::Ptr preview = std::dynamic_pointer_cast<ApplicationPreview>(base_preview);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-application");
+  EXPECT_EQ(preview->title, "Title");
+  EXPECT_EQ(preview->subtitle, "Subtitle");
+  EXPECT_EQ(preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
+  EXPECT_EQ(preview->last_update, "2012/06/13");
+  EXPECT_EQ(preview->copyright, "(c) Canonical");
+  EXPECT_EQ(preview->license, "GPLv3");
+  EXPECT_TRUE(g_icon_equal(preview->app_icon(), icon) != FALSE);
+  EXPECT_EQ(preview->rating, 4.0);
+  EXPECT_EQ(preview->num_ratings, static_cast<unsigned>(12));
+}
+
+TEST(TestPreviews, DeserializeMovie)
+{
+  Object<GIcon> icon(g_icon_new_for_string("movie", NULL));
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_movie_preview_new()));
+  unity_protocol_preview_set_title(proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(proto_obj, icon);
+  auto movie_proto_obj = glib::object_cast<UnityProtocolMoviePreview>(proto_obj);
+  unity_protocol_movie_preview_set_year(movie_proto_obj, "2012");
+  unity_protocol_movie_preview_set_rating(movie_proto_obj, 4.0);
+  unity_protocol_movie_preview_set_num_ratings(movie_proto_obj, 12);
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
+  MoviePreview::Ptr preview = std::dynamic_pointer_cast<MoviePreview>(base_preview);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-movie");
+  EXPECT_EQ(preview->title, "Title");
+  EXPECT_EQ(preview->subtitle, "Subtitle");
+  EXPECT_EQ(preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
+  EXPECT_EQ(preview->year, "2012");
+  EXPECT_EQ(preview->rating, 4.0);
+  EXPECT_EQ(preview->num_ratings, static_cast<unsigned int>(12));
+}
+
+TEST(TestPreviews, DeserializeMusic)
+{
+  Object<GIcon> icon(g_icon_new_for_string("music", NULL));
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_music_preview_new()));
+  unity_protocol_preview_set_title(proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(proto_obj, icon);
+  auto music_proto_obj = glib::object_cast<UnityProtocolMusicPreview>(proto_obj);
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
+  MusicPreview::Ptr preview = std::dynamic_pointer_cast<MusicPreview>(base_preview);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-music");
+  EXPECT_EQ(preview->title, "Title");
+  EXPECT_EQ(preview->subtitle, "Subtitle");
+  EXPECT_EQ(preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
+}
+
+TEST(TestPreviews, DeserializeSeries)
+{
+  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_series_preview_new()));
+  auto series_proto_obj = glib::object_cast<UnityProtocolSeriesPreview>(proto_obj);
+  unity_protocol_series_preview_add_series_item(
+      series_proto_obj, "#1", "scheme://path/0", NULL);
+  unity_protocol_series_preview_add_series_item(
+      series_proto_obj, "#2", "scheme://path/1", NULL);
+  unity_protocol_series_preview_set_selected_item(series_proto_obj, 1);
+
+  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
+  Object<UnityProtocolPreview> child_proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
+  unity_protocol_preview_set_title(child_proto_obj, "Title");
+  unity_protocol_preview_set_subtitle(child_proto_obj, "Subtitle");
+  unity_protocol_preview_set_description(child_proto_obj, "Description");
+  unity_protocol_preview_set_thumbnail(child_proto_obj, icon);
+
+  unity_protocol_series_preview_set_child_preview(series_proto_obj,
+      child_proto_obj);
+
+  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
+            glib::StealRef());
+  EXPECT_TRUE(IsVariant(v));
+
+  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
+  SeriesPreview::Ptr preview = std::dynamic_pointer_cast<SeriesPreview>(base_preview);
+  EXPECT_TRUE(preview != nullptr);
+
+  EXPECT_EQ(preview->renderer_name, "preview-series");
+
+  auto items = preview->GetItems();
+  EXPECT_EQ(items.size(), 2);
+
+  auto item1 = preview->GetItems()[1];
+  EXPECT_EQ(item1->uri, "scheme://path/1");
+  EXPECT_EQ(item1->title, "#2");
+
+  auto child_preview = preview->GetChildPreview();
+  EXPECT_EQ(child_preview->renderer_name, "preview-generic");
+  EXPECT_EQ(child_preview->title, "Title");
+  EXPECT_EQ(child_preview->subtitle, "Subtitle");
+  EXPECT_EQ(child_preview->description, "Description");
+  EXPECT_TRUE(g_icon_equal(child_preview->image(), icon) != FALSE);
+}
+
+} // Namespace

=== modified file 'tests/test_service_lens.c'
--- tests/test_service_lens.c	2012-06-06 12:42:59 +0000
+++ tests/test_service_lens.c	2012-07-17 13:45:25 +0000
@@ -174,7 +174,7 @@
     g_free(name);
   }
 
-  g_signal_emit_by_name (search, "finished");
+  unity_lens_search_finished (search);
 }
 
 static UnityActivationResponse*
@@ -183,15 +183,51 @@
   return unity_activation_response_new(UNITY_HANDLED_TYPE_HIDE_DASH, "");
 }
 
+static UnityActivationResponse*
+preview_action_activated(UnityPreviewAction* action, const char* uri)
+{
+  return unity_activation_response_new(UNITY_HANDLED_TYPE_SHOW_DASH, "");
+}
+
+static UnityPreview*
+generate_child_preview(UnitySeriesPreview* parent, const char* uri)
+{
+  UnityPreview* preview;
+  UnityPreviewAction *action;
+
+  gchar* desc = g_strdup_printf("Description for an item with uri %s", uri);
+  preview = (UnityPreview*) unity_generic_preview_new("A preview", desc, NULL);
+  action = unity_preview_action_new("child_action_X", "An action", NULL);
+  unity_preview_add_action(preview, action);
+  g_signal_connect(action, "activated",
+                   G_CALLBACK(preview_action_activated), NULL);
+
+  g_free(desc);
+  return preview;
+}
+
 static UnityPreview*
 on_preview_uri(UnityScope* scope, const char* uri, ServiceLens *self)
 {
-  return NULL;
-  // FIXME: update when the new preview types are well defined
-  /*
-  return (UnityPreview*)unity_generic_preview_new(
-      "Animus Vox", "The Glitch Mob - Drink The Sea", NULL);
-  */
+  UnityPreviewAction* action;
+  UnitySeriesPreview* preview;
+  UnitySeriesItem* series_items[4];
+
+  series_items[0] = unity_series_item_new("scheme://item/1", "Item #1", NULL);
+  series_items[1] = unity_series_item_new("scheme://item/2", "Item #2", NULL);
+  series_items[2] = unity_series_item_new("scheme://item/3", "Item #3", NULL);
+  series_items[3] = unity_series_item_new("scheme://item/4", "Item #4", NULL);
+
+  preview = unity_series_preview_new(series_items, 4, "scheme://item/3");
+  g_signal_connect(preview, "request-item-preview",
+                   G_CALLBACK(generate_child_preview), NULL);
+
+  action = unity_preview_action_new("series_action_A", "An action", NULL);
+  unity_preview_add_action(UNITY_PREVIEW(preview), action);
+  g_signal_connect(action, "activated",
+                   G_CALLBACK(preview_action_activated), NULL);
+
+  return (UnityPreview*) preview;
 }
 
 ServiceLens*