Merge lp:~alecu/unity-scope-click/uninstall-scopes into lp:unity-scope-click/devel

[Alejandro J. Cura]

Allow installed packages in the Available category

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:281
http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-ci/92/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-amd64-ci/67
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-armhf-ci/66
        deb: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-armhf-ci/66/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-i386-ci/66

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-team-unity-scope-click-devel-ci/92/rebuild

review: Approve (continuous-integration)

[lp:~alecu/unity-scope-click/uninstall-scopes]

282. By Alejandro J. Cura on 2014-06-03

Include subtitle with price or Installed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:282
http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-ci/93/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-amd64-ci/68
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-armhf-ci/67
        deb: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-armhf-ci/67/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-scope-click-devel-utopic-i386-ci/67

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-team-unity-scope-click-devel-ci/93/rebuild

review: Approve (continuous-integration)

[lp:~alecu/unity-scope-click/uninstall-scopes]

283. By Alejandro J. Cura on 2014-06-03

Use the proper list of installed packages

284. By Alejandro J. Cura on 2014-06-03

Merged with lp:~stolowski/unity-scope-click/two-scopes

285. By Alejandro J. Cura on 2014-06-03

Fix broken tests after the merge

286. By Alejandro J. Cura on 2014-06-04

Removing fit, changing aspect-ratio to 1.13

287. By Alejandro J. Cura on 2014-06-04

Merged from lp:~stolowski/unity-scope-click/two-scopes

288. By Alejandro J. Cura on 2014-06-06

Test for get_installed_packages async->sync method

289. By Alejandro J. Cura on 2014-06-06

Use a typedef for PackageNames

290. By Alejandro J. Cura on 2014-06-06

After talking with pawel, realized keeping this was a mixup from the merge

291. By Alejandro J. Cura on 2014-06-06

Make new strings translatable

292. By Alejandro J. Cura on 2014-06-06

Better reporting of errors when parsing the output of 'click list'

293. By Alejandro J. Cura on 2014-06-06

Simplified parsing of click list lines

294. By Alejandro J. Cura on 2014-06-07

Use a set of Packages instead of the Packages' names

295. By Alejandro J. Cura on 2014-06-07

Store the installed version in the scope result

296. By Alejandro J. Cura on 2014-06-10

Allow searching installed scopes

297. By Alejandro J. Cura on 2014-06-11

Use the package name for the scope id

298. By Alejandro J. Cura on 2014-06-12

merged with devel

Unmerged revisions

298. By Alejandro J. Cura on 2014-06-12

merged with devel

297. By Alejandro J. Cura on 2014-06-11

Use the package name for the scope id

296. By Alejandro J. Cura on 2014-06-10

Allow searching installed scopes

295. By Alejandro J. Cura on 2014-06-07

Store the installed version in the scope result

294. By Alejandro J. Cura on 2014-06-07

Use a set of Packages instead of the Packages' names

293. By Alejandro J. Cura on 2014-06-06

Simplified parsing of click list lines

292. By Alejandro J. Cura on 2014-06-06

Better reporting of errors when parsing the output of 'click list'

291. By Alejandro J. Cura on 2014-06-06

Make new strings translatable

290. By Alejandro J. Cura on 2014-06-06

After talking with pawel, realized keeping this was a mixup from the merge

289. By Alejandro J. Cura on 2014-06-06

Use a typedef for PackageNames

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-05-23 18:47:34 +0000
+++ CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -14,8 +14,10 @@
 
 include(GNUInstallDirs)
 
-set(SCOPE_LIB_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/clickscope/)
-set(SCOPE_DATA_DIR ${CMAKE_INSTALL_FULL_DATADIR}/unity/scopes/clickscope/)
+set(STORE_LIB_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/clickstore/)
+set(STORE_DATA_DIR ${CMAKE_INSTALL_FULL_DATADIR}/unity/scopes/clickstore/)
+set(APPS_LIB_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/clickapps/)
+set(APPS_DATA_DIR ${CMAKE_INSTALL_FULL_DATADIR}/unity/scopes/clickapps/)
 
 include(FindPkgConfig)
 
@@ -32,8 +34,11 @@
 SET (SCOPE_LIB_VERSION 0.2.0)
 SET (SCOPE_LIB_SOVERSION 0)
 SET (SCOPE_LIB_API_VERSION 2.0)
-SET (SCOPE_LIB_UNVERSIONED clickscope)
-SET (SCOPE_LIB_NAME ${SCOPE_LIB_UNVERSIONED}-${SCOPE_LIB_API_VERSION})
+SET (STORE_LIB_UNVERSIONED com.canonical.scopes.clickstore)
+SET (SCOPE_LIB_NAME clickscope)
+SET (STORE_LIB_NAME ${STORE_LIB_UNVERSIONED}-${SCOPE_LIB_API_VERSION})
+SET (APPS_LIB_UNVERSIONED scope)
+SET (APPS_LIB_NAME ${APPS_LIB_UNVERSIONED}-${SCOPE_LIB_API_VERSION})
 
 # Build with system gmock and embedded gtest
 set (GMOCK_INCLUDE_DIR "/usr/include/gmock/include" CACHE PATH "gmock source include directory")
@@ -108,4 +113,4 @@
 
 add_custom_target (check-leaks
   DEPENDS test-leaks
-)
 \ No newline at end of file
+)
 
=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2014-04-29 18:42:40 +0000
+++ data/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -1,21 +1,43 @@
 find_program(INTLTOOL_MERGE intltool-merge)
-set(SCOPE_INI_TARGET clickscope.ini)
-
-configure_file(
-  ${SCOPE_INI_TARGET}.in.in
-  ${SCOPE_INI_TARGET}.in
-)
-
-add_custom_target(${SCOPE_INI_TARGET} ALL
-  COMMENT "Merging translations into ${SCOPE_INI_TARGET}"
-  COMMAND LC_ALL=C ${INTLTOOL_MERGE} -d -u ${CMAKE_SOURCE_DIR}/po ${SCOPE_INI_TARGET}.in ${SCOPE_INI_TARGET} >/dev/null
-)
-
-install(
-  FILES clickscope-screenshot.jpg apps-scope.svg
-  DESTINATION "${SCOPE_DATA_DIR}"
-)
-install(
-  FILES "${CMAKE_CURRENT_BINARY_DIR}/${SCOPE_INI_TARGET}"
-  DESTINATION "${SCOPE_LIB_DIR}"
+set(STORE_INI_TARGET com.canonical.scopes.clickstore.ini)
+set(APPS_INI_TARGET clickscope.ini)
+
+configure_file(
+  ${STORE_INI_TARGET}.in.in
+  ${STORE_INI_TARGET}.in
+)
+
+configure_file(
+  ${APPS_INI_TARGET}.in.in
+  ${APPS_INI_TARGET}.in
+)
+
+add_custom_target(${STORE_INI_TARGET} ALL
+  COMMENT "Merging translations into ${STORE_INI_TARGET}"
+  COMMAND LC_ALL=C ${INTLTOOL_MERGE} -d -u ${CMAKE_SOURCE_DIR}/po ${STORE_INI_TARGET}.in ${STORE_INI_TARGET} >/dev/null
+)
+
+add_custom_target(${APPS_INI_TARGET} ALL
+  COMMENT "Merging translations into ${APPS_INI_TARGET}"
+  COMMAND LC_ALL=C ${INTLTOOL_MERGE} -d -u ${CMAKE_SOURCE_DIR}/po ${APPS_INI_TARGET}.in ${APPS_INI_TARGET} >/dev/null
+)
+
+install(
+  FILES clickscope-screenshot.jpg apps-scope.svg
+  DESTINATION "${STORE_DATA_DIR}"
+)
+
+install(
+  FILES clickscope-screenshot.jpg apps-scope.svg
+  DESTINATION "${APPS_DATA_DIR}"
+)
+
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/${STORE_INI_TARGET}"
+  DESTINATION "${STORE_LIB_DIR}"
+)
+
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/${APPS_INI_TARGET}"
+  DESTINATION "${APPS_LIB_DIR}"
 )
 
=== added file 'data/clickscope.ini.in.in'
--- data/clickscope.ini.in.in	1970-01-01 00:00:00 +0000
+++ data/clickscope.ini.in.in	2014-06-06 00:43:07 +0000
@@ -0,0 +1,8 @@
+[ScopeConfig]
+_DisplayName=Apps
+_Description=Scope for searching the installed click apps
+Author=Canonical Ltd.
+Art=@APPS_DATA_DIR@/clickscope-screenshot.jpg
+Icon=@APPS_DATA_DIR@/apps-scope.svg
+SearchHint=clickscope.SearchHint
+HotKey=clickscope.HotKey
 
=== renamed file 'data/clickscope.ini.in.in' => 'data/com.canonical.scopes.clickstore.ini.in.in'
--- data/clickscope.ini.in.in	2014-04-29 18:42:40 +0000
+++ data/com.canonical.scopes.clickstore.ini.in.in	2014-06-06 00:43:07 +0000
@@ -1,8 +1,8 @@
 [ScopeConfig]
-_DisplayName=Apps
+_DisplayName=Ubuntu Store
 _Description=Scope for searching the click app store
 Author=Canonical Ltd.
-Art=@SCOPE_DATA_DIR@/clickscope-screenshot.jpg
-Icon=@SCOPE_DATA_DIR@/apps-scope.svg
+Art=@STORE_DATA_DIR@/clickscope-screenshot.jpg
+Icon=@STORE_DATA_DIR@/apps-scope.svg
 SearchHint=clickscope.SearchHint
 HotKey=clickscope.HotKey
 
=== modified file 'libclickscope/click/interface.cpp'
--- libclickscope/click/interface.cpp	2014-05-26 14:02:45 +0000
+++ libclickscope/click/interface.cpp	2014-06-06 00:43:07 +0000
@@ -217,11 +217,6 @@
     };
 
     keyFileLocator->enumerateKeyFilesForInstalledApplications(enumerator);
-    // Sort applications so that newest come first.
-    std::sort(result.begin(), result.end(), [](const Application& a,
-                                               const Application& b) {
-                  return a.installed_time > b.installed_time;
-              });
     return result;
 }
 
@@ -321,7 +316,7 @@
     return manifest;
 }
 
-void Interface::get_manifests(std::function<void(ManifestList, ManifestError)> callback)
+void Interface::get_manifests(std::function<void(ManifestList, InterfaceError)> callback)
 {
     std::string command = "click list --manifest";
     qDebug() << "Running command:" << command.c_str();
@@ -329,18 +324,57 @@
         if (code == 0) {
             try {
                 ManifestList manifests = manifest_list_from_json(stdout_data);
-                callback(manifests, ManifestError::NoError);
-            } catch (...) {
-                callback(ManifestList(), ManifestError::ParseError);
-            }
-        } else {
-            callback(ManifestList(), ManifestError::CallError);
+                callback(manifests, InterfaceError::NoError);
+            } catch (...) {
+                callback(ManifestList(), InterfaceError::ParseError);
+            }
+        } else {
+            callback(ManifestList(), InterfaceError::CallError);
+        }
+    });
+}
+
+PackageNames package_names_from_stdout(std::string stdout_data)
+{
+    PackageNames package_names;
+    const char newline = '\n';
+    const char tab = '\t';
+
+    size_t linestart = 0, tabpos;
+    size_t eof = stdout_data.length();
+
+    while (linestart < eof) {
+        tabpos = stdout_data.find_first_of(tab, linestart);
+        if (tabpos == std::string::npos) {
+            throw std::runtime_error("No tab in click list line");
+        }
+        package_names.insert(stdout_data.substr(linestart, tabpos-linestart));
+        linestart = stdout_data.find_first_of(newline, tabpos) + 1;
+    }
+
+    return package_names;
+}
+
+void Interface::get_installed_packagenames(std::function<void(PackageNames, InterfaceError)> callback)
+{
+    std::string command = "click list";
+    qDebug() << "Running command:" << command.c_str();
+    run_process(command, [callback](int code, const std::string& stdout_data, const std::string&) {
+        if (code == 0) {
+            try {
+                PackageNames package_names = package_names_from_stdout(stdout_data);
+                callback(package_names, InterfaceError::NoError);
+            } catch (...) {
+                callback({}, InterfaceError::ParseError);
+            }
+        } else {
+            callback({}, InterfaceError::CallError);
         }
     });
 }
 
 void Interface::get_manifest_for_app(const std::string &app_id,
-                                     std::function<void(Manifest, ManifestError)> callback)
+                                     std::function<void(Manifest, InterfaceError)> callback)
 {
     std::string command = "click info " + app_id;
     qDebug() << "Running command:" << command.c_str();
@@ -348,23 +382,23 @@
         if (code == 0) {
             try {
                 Manifest manifest = manifest_from_json(stdout_data);
-                callback(manifest, ManifestError::NoError);
+                callback(manifest, InterfaceError::NoError);
             } catch (...) {
-                callback(Manifest(), ManifestError::ParseError);
+                callback(Manifest(), InterfaceError::ParseError);
             }
         } else {
-            callback(Manifest(), ManifestError::CallError);
+            callback(Manifest(), InterfaceError::CallError);
         }
     });
 }
 
 void Interface::get_dotdesktop_filename(const std::string &app_id,
-                                        std::function<void(std::string, ManifestError)> callback)
+                                        std::function<void(std::string, InterfaceError)> callback)
 {
-    get_manifest_for_app(app_id, [app_id, callback] (Manifest manifest, ManifestError error) {
+    get_manifest_for_app(app_id, [app_id, callback] (Manifest manifest, InterfaceError error) {
         qDebug() << "in get_dotdesktop_filename callback";
 
-        if (error != ManifestError::NoError){
+        if (error != InterfaceError::NoError){
             callback(std::string("Internal Error"), error);
             return;
         }
@@ -372,10 +406,10 @@
 
         if (!manifest.name.empty()) {
             std::string ddstr = manifest.name + "_" + manifest.first_app_name + "_" + manifest.version + ".desktop";
-            callback(ddstr, ManifestError::NoError);
+            callback(ddstr, InterfaceError::NoError);
         } else {
             qCritical() << "Warning: no manifest found for " << app_id.c_str();
-            callback(std::string("Not found"), ManifestError::CallError);
+            callback(std::string("Not found"), InterfaceError::CallError);
         }
     });
 }
 
=== modified file 'libclickscope/click/interface.h'
--- libclickscope/click/interface.h	2014-05-26 14:02:45 +0000
+++ libclickscope/click/interface.h	2014-06-06 00:43:07 +0000
@@ -62,12 +62,14 @@
     bool removable = false;
 };
 
-enum class ManifestError {NoError, CallError, ParseError};
+enum class InterfaceError {NoError, CallError, ParseError};
 typedef std::list<Manifest> ManifestList;
 
 ManifestList manifest_list_from_json(const std::string& json);
 Manifest manifest_from_json(const std::string& json);
 
+typedef std::unordered_set<std::string> PackageNames;
+
 class Interface
 {
 public:
@@ -87,10 +89,11 @@
 
     static bool is_icon_identifier(const std::string &icon_id);
     static std::string add_theme_scheme(const std::string &filename);
-    virtual void get_manifests(std::function<void(ManifestList, ManifestError)> callback);
-    virtual void get_manifest_for_app(const std::string &app_id, std::function<void(Manifest, ManifestError)> callback);
+    virtual void get_manifests(std::function<void(ManifestList, InterfaceError)> callback);
+    virtual void get_installed_packagenames(std::function<void(PackageNames, InterfaceError)> callback);
+    virtual void get_manifest_for_app(const std::string &app_id, std::function<void(Manifest, InterfaceError)> callback);
     virtual void get_dotdesktop_filename(const std::string &app_id,
-                                        std::function<void(std::string filename, ManifestError)> callback);
+                                        std::function<void(std::string filename, InterfaceError)> callback);
     constexpr static const char* ENV_SHOW_DESKTOP_APPS {"CLICK_SCOPE_SHOW_DESKTOP_APPS"};
     virtual bool is_visible_app(const unity::util::IniParser& keyFile);
     virtual bool show_desktop_apps();
 
=== modified file 'libclickscope/click/preview.cpp'
--- libclickscope/click/preview.cpp	2014-05-26 14:02:45 +0000
+++ libclickscope/click/preview.cpp	2014-06-06 00:43:07 +0000
@@ -100,6 +100,10 @@
         }
     } else {
         // metadata.scope_data() is Null, so we return an appropriate "default" preview:
+        if (result.uri().find("scope://") == 0)
+        {
+            return new InstalledScopePreview(result);
+        }
         if (result["installed"].get_bool() == true) {
             return new InstalledPreview(result, metadata, client);
         } else {
@@ -435,7 +439,7 @@
     if (!app_name.empty()) {
         qt::core::world::enter_with_task([&]() {
             click::Interface().get_manifest_for_app(app_name,
-                [&](Manifest manifest, ManifestError error) {
+                [&](Manifest manifest, InterfaceError error) {
                     qDebug() << "Got manifest for:" << app_name.c_str();
                     removable = manifest.removable;
 
@@ -443,7 +447,7 @@
                     review.package_name = manifest.name;
                     review.package_version = manifest.version;
 
-                    if (error != click::ManifestError::NoError) {
+                    if (error != click::InterfaceError::NoError) {
                         qDebug() << "There was an error getting the manifest for:" << app_name.c_str();
                     }
                     manifest_promise.set_value(true);
@@ -532,9 +536,9 @@
         auto ft = qt::core::world::enter_with_task([this, name, callback] ()
         {
             click::Interface().get_dotdesktop_filename(name,
-                                          [callback] (std::string val, click::ManifestError error) {
+                                          [callback] (std::string val, click::InterfaceError error) {
                                           std::string uri;
-                                          if (error == click::ManifestError::NoError) {
+                                          if (error == click::InterfaceError::NoError) {
                                               uri = "application:///" + val;
                                           }
                                           callback(uri);
@@ -547,6 +551,30 @@
     }
 }
 
+// class InstalledScopePreview
+// this is a temporary fallback preview to get into the Store scope, the proper
+// requires 'store' category to be treated special (like 'local') in unity8 shell.
+
+InstalledScopePreview::InstalledScopePreview(const unity::scopes::Result& result)
+    : PreviewStrategy(result)
+{
+}
+
+void InstalledScopePreview::run(unity::scopes::PreviewReplyProxy const& reply)
+{
+    scopes::PreviewWidget actions("actions", "actions");
+    {
+        scopes::VariantBuilder builder;
+        builder.add_tuple({
+                {"id", scopes::Variant("search")},
+                {"uri", scopes::Variant(result.uri())},
+                {"label", scopes::Variant(_("Search"))}
+            });
+        actions.add_attribute_value("actions", builder.end());
+    }
+
+    reply->push({actions});
+}
 
 // class PurchasingPreview
 
 
=== modified file 'libclickscope/click/preview.h'
--- libclickscope/click/preview.h	2014-05-26 14:02:45 +0000
+++ libclickscope/click/preview.h	2014-06-06 00:43:07 +0000
@@ -172,6 +172,13 @@
     scopes::ActionMetadata metadata;
 };
 
+class InstalledScopePreview : public PreviewStrategy
+{
+public:
+    InstalledScopePreview(const unity::scopes::Result& result);
+    void run(unity::scopes::PreviewReplyProxy const& reply) override;
+};
+
 class PurchasingPreview : public PreviewStrategy
 {
 public:
 
=== modified file 'libclickscope/click/scope_activation.cpp'
--- libclickscope/click/scope_activation.cpp	2014-05-26 14:02:45 +0000
+++ libclickscope/click/scope_activation.cpp	2014-06-06 00:43:07 +0000
@@ -28,6 +28,9 @@
  */
 
 #include "scope_activation.h"
+#include <click/package.h>
+#include <click/interface.h>
+#include <click/qtbridge.h>
 #include <unity/scopes/ActivationResponse.h>
 
 unity::scopes::ActivationResponse click::ScopeActivation::activate()
@@ -46,3 +49,31 @@
 {
     hints_[key] = value;
 }
+
+click::PerformUninstallAction::PerformUninstallAction(const unity::scopes::Result& result, const unity::scopes::ActivationResponse& response)
+    : result(result),
+      response(response)
+{
+}
+
+unity::scopes::ActivationResponse click::PerformUninstallAction::activate()
+{
+    click::Package package;
+    package.title = result.title();
+    package.name = result["name"].get_string();
+    package.version = result["version"].get_string();
+    qt::core::world::enter_with_task([this, package] ()
+    {
+        click::PackageManager manager;
+        manager.uninstall(package, [&](int code, std::string stderr_content) {
+                if (code != 0) {
+                    qDebug() << "Error removing package:" << stderr_content.c_str();
+                } else {
+                    qDebug() << "successfully removed package";
+
+                }
+            } );
+    });
+
+    return response;
+}
 
=== modified file 'libclickscope/click/scope_activation.h'
--- libclickscope/click/scope_activation.h	2014-05-26 14:02:45 +0000
+++ libclickscope/click/scope_activation.h	2014-06-06 00:43:07 +0000
@@ -31,10 +31,23 @@
 #define CLICK_SCOPE_ACTIVATION_H
 
 #include <unity/scopes/ActivationQueryBase.h>
+#include <unity/scopes/ActivationResponse.h>
+#include <unity/scopes/Result.h>
 
 namespace click
 {
 
+class PerformUninstallAction: public unity::scopes::ActivationQueryBase
+{
+public:
+    PerformUninstallAction(const unity::scopes::Result& result, const unity::scopes::ActivationResponse& response);
+    unity::scopes::ActivationResponse activate() override;
+
+private:
+    unity::scopes::Result result;
+    unity::scopes::ActivationResponse response;
+};
+
 class ScopeActivation : public unity::scopes::ActivationQueryBase
 {
     unity::scopes::ActivationResponse activate() override;
 
=== modified file 'libclickscope/tests/test_interface.cpp'
--- libclickscope/tests/test_interface.cpp	2014-05-26 14:27:31 +0000
+++ libclickscope/tests/test_interface.cpp	2014-06-06 00:43:07 +0000
@@ -118,8 +118,9 @@
 
 class ClickInterfaceTest : public ::testing::Test {
 public:
-    MOCK_METHOD2(manifest_callback, void(Manifest, ManifestError));
-    MOCK_METHOD2(manifests_callback, void(ManifestList, ManifestError));
+    MOCK_METHOD2(manifest_callback, void(Manifest, InterfaceError));
+    MOCK_METHOD2(manifests_callback, void(ManifestList, InterfaceError));
+    MOCK_METHOD2(installed_callback, void(PackageNames, InterfaceError));
 };
 
 }
@@ -326,7 +327,7 @@
     std::string command = "click info " + FAKE_PACKAGENAME;
     EXPECT_CALL(iface, run_process(command, _)).
         Times(1);
-    iface.get_manifest_for_app(FAKE_PACKAGENAME, [](Manifest, ManifestError){});
+    iface.get_manifest_for_app(FAKE_PACKAGENAME, [](Manifest, InterfaceError){});
 }
 
 TEST_F(ClickInterfaceTest, testGetManifestForAppParseError)
@@ -339,9 +340,9 @@
                                                const std::string&)> callback){
                             callback(0, "INVALID JSON", "");
                         }));
-    EXPECT_CALL(*this, manifest_callback(_, ManifestError::ParseError));
+    EXPECT_CALL(*this, manifest_callback(_, InterfaceError::ParseError));
     iface.get_manifest_for_app(FAKE_PACKAGENAME, [this](Manifest manifest,
-                                                        ManifestError error){
+                                                        InterfaceError error){
                                    manifest_callback(manifest, error);
                                });
 }
@@ -356,9 +357,9 @@
                                                const std::string&)> callback){
                             callback(-1, "", "CRITICAL: FAIL");
                         }));
-    EXPECT_CALL(*this, manifest_callback(_, ManifestError::CallError));
+    EXPECT_CALL(*this, manifest_callback(_, InterfaceError::CallError));
     iface.get_manifest_for_app(FAKE_PACKAGENAME, [this](Manifest manifest,
-                                                        ManifestError error){
+                                                        InterfaceError error){
                                    manifest_callback(manifest, error);
                                });
 }
@@ -374,8 +375,8 @@
                             callback(0, FAKE_JSON_MANIFEST_REMOVABLE, "");
                         }));
     iface.get_manifest_for_app(FAKE_PACKAGENAME, [](Manifest manifest,
-                                                    ManifestError error){
-                                   ASSERT_TRUE(error == ManifestError::NoError);
+                                                    InterfaceError error){
+                                   ASSERT_TRUE(error == InterfaceError::NoError);
                                    ASSERT_TRUE(manifest.removable);
                                });
 }
@@ -391,8 +392,8 @@
                             callback(0, FAKE_JSON_MANIFEST_NONREMOVABLE, "");
                         }));
     iface.get_manifest_for_app(FAKE_PACKAGENAME, [](Manifest manifest,
-                                                    ManifestError error){
-                                   ASSERT_TRUE(error == ManifestError::NoError);
+                                                    InterfaceError error){
+                                   ASSERT_TRUE(error == InterfaceError::NoError);
                                    ASSERT_FALSE(manifest.removable);
                                });
 }
@@ -403,7 +404,7 @@
     std::string command = "click list --manifest";
     EXPECT_CALL(iface, run_process(command, _)).
         Times(1);
-    iface.get_manifests([](ManifestList, ManifestError){});
+    iface.get_manifests([](ManifestList, InterfaceError){});
 }
 
 TEST_F(ClickInterfaceTest, testGetManifestsParseError)
@@ -416,8 +417,8 @@
                                                const std::string&)> callback){
                             callback(0, "INVALID JSON", "");
                         }));
-    EXPECT_CALL(*this, manifests_callback(_, ManifestError::ParseError));
-    iface.get_manifests([this](ManifestList manifests, ManifestError error){
+    EXPECT_CALL(*this, manifests_callback(_, InterfaceError::ParseError));
+    iface.get_manifests([this](ManifestList manifests, InterfaceError error){
             manifests_callback(manifests, error);
         });
 }
@@ -432,8 +433,8 @@
                                                const std::string&)> callback){
                             callback(-1, "", "CRITICAL: FAIL");
                         }));
-    EXPECT_CALL(*this, manifests_callback(_, ManifestError::CallError));
-    iface.get_manifests([this](ManifestList manifests, ManifestError error){
+    EXPECT_CALL(*this, manifests_callback(_, InterfaceError::CallError));
+    iface.get_manifests([this](ManifestList manifests, InterfaceError error){
             manifests_callback(manifests, error);
         });
 }
@@ -452,8 +453,69 @@
                                                const std::string&)> callback){
                             callback(0, expected_str, "");
                         }));
-    iface.get_manifests([expected](ManifestList manifests, ManifestError error){
-            ASSERT_TRUE(error == ManifestError::NoError);
+    iface.get_manifests([expected](ManifestList manifests, InterfaceError error){
+            ASSERT_TRUE(error == InterfaceError::NoError);
             ASSERT_TRUE(manifests.size() == expected.size());
         });
 }
+
+TEST(ClickInterface, testGetInstalledPackagesCorrectCommand)
+{
+    FakeClickInterface iface;
+    std::string command = "click list";
+    EXPECT_CALL(iface, run_process(command, _)).
+        Times(1);
+    iface.get_installed_packagenames([](PackageNames, InterfaceError){});
+}
+
+TEST_F(ClickInterfaceTest, testGetInstalledPackagesParseError)
+{
+    FakeClickInterface iface;
+    EXPECT_CALL(iface, run_process(_, _)).
+        Times(1).
+        WillOnce(Invoke([&](const std::string&,
+                            std::function<void(int, const std::string&,
+                                               const std::string&)> callback){
+                            callback(0, "valid\t\nINVALID LINE\n", "");
+                        }));
+    EXPECT_CALL(*this, installed_callback(_, InterfaceError::ParseError));
+    iface.get_installed_packagenames([this](PackageNames package_names, InterfaceError error){
+            installed_callback(package_names, error);
+        });
+}
+
+TEST_F(ClickInterfaceTest, testGetInstalledPackagesCommandFailed)
+{
+    FakeClickInterface iface;
+    EXPECT_CALL(iface, run_process(_, _)).
+        Times(1).
+        WillOnce(Invoke([&](const std::string&,
+                            std::function<void(int, const std::string&,
+                                               const std::string&)> callback){
+                            callback(-1, "", "CRITICAL: FAIL");
+                        }));
+    EXPECT_CALL(*this, installed_callback(_, InterfaceError::CallError));
+    iface.get_installed_packagenames([this](PackageNames package_names, InterfaceError error){
+            installed_callback(package_names, error);
+        });
+}
+
+TEST_F(ClickInterfaceTest, testGetInstalledPackagesParsed)
+{
+    FakeClickInterface iface;
+    std::string sample_stdout = "ABC\t0.1\nDEF\t0.2\n";
+    PackageNames expected{"ABC", "DEF"};
+
+    EXPECT_CALL(iface, run_process(_, _)).
+        Times(1).
+        WillOnce(Invoke([&](const std::string&,
+                            std::function<void(int, const std::string&,
+                                               const std::string&)> callback){
+                            callback(0, sample_stdout, "");
+                        }));
+    iface.get_installed_packagenames([expected](PackageNames package_names, InterfaceError error){
+            ASSERT_EQ(error, InterfaceError::NoError);
+            ASSERT_EQ(package_names, expected);
+    });
+}
+
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2014-04-29 18:42:40 +0000
+++ po/POTFILES.in	2014-06-06 00:43:07 +0000
@@ -1,3 +1,5 @@
-[type: gettext/ini] data/clickscope.ini.in.in
-scope/click/preview.cpp
-scope/click/query.cpp
+[type: gettext/ini] data/com.canonical.scopes.clickstore.ini.in.in
+data/clickscope.ini.in.in
+libclickscope/click/preview.cpp
+scope/clickapps/apps-query.cpp
+scope/clickstore/store-query.cpp
 
=== modified file 'scope/CMakeLists.txt'
--- scope/CMakeLists.txt	2014-01-28 08:49:16 +0000
+++ scope/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -1,2 +1,3 @@
-add_subdirectory(click)
-add_subdirectory(tests)
 \ No newline at end of file
+add_subdirectory(clickstore)
+add_subdirectory(clickapps)
+add_subdirectory(tests)
 
=== added directory 'scope/clickapps'
=== added file 'scope/clickapps/CMakeLists.txt'
--- scope/clickapps/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ scope/clickapps/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -0,0 +1,37 @@
+SET (CMAKE_INCLUDE_CURRENT_DIR ON)
+SET (CMAKE_AUTOMOC ON)
+find_package (Qt5Core REQUIRED)
+pkg_check_modules(JSON_CPP REQUIRED jsoncpp)
+
+add_definitions(
+  -DGETTEXT_PACKAGE=\"${PROJECT_NAME}\"
+  -DGETTEXT_LOCALEDIR=\"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LOCALEDIR}\"
+  -DSTORE_DATA_DIR="${STORE_DATA_DIR}"
+)
+
+add_library(${APPS_LIB_UNVERSIONED} SHARED
+  apps-query.cpp
+  apps-scope.cpp
+)
+set_target_properties(${APPS_LIB_UNVERSIONED} PROPERTIES PREFIX "")
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/libclickscope
+  ${JSON_CPP_INCLUDE_DIRS}
+)
+
+qt5_use_modules (${APPS_LIB_UNVERSIONED} Network)
+
+target_link_libraries (${APPS_LIB_UNVERSIONED}
+  ${SCOPE_LIB_NAME}
+  ${JSON_CPP_LDFLAGS}
+  ${UNITY_SCOPES_LDFLAGS}
+  ${UBUNTUONE_LDFLAGS}
+  ${UBUNTU_DOWNLOAD_MANAGER_CLIENT_LDFLAGS}
+  ${UBUNTU_DOWNLOAD_MANAGER_COMMON_LDFLAGS}
+)
+
+install(
+  TARGETS ${APPS_LIB_UNVERSIONED}
+  LIBRARY DESTINATION "${APPS_LIB_DIR}"
+  )
 
=== added file 'scope/clickapps/apps-query.cpp'
--- scope/clickapps/apps-query.cpp	1970-01-01 00:00:00 +0000
+++ scope/clickapps/apps-query.cpp	2014-06-06 00:43:07 +0000
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2014 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include <click/application.h>
+#include <click/interface.h>
+
+#include <click/key_file_locator.h>
+
+#include <unity/scopes/CategoryRenderer.h>
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/CannedQuery.h>
+#include <unity/scopes/SearchReply.h>
+#include <unity/scopes/SearchMetadata.h>
+
+#include <vector>
+
+#include <click/click-i18n.h>
+#include "apps-query.h"
+
+namespace
+{
+
+std::string CATEGORY_APPS_DISPLAY = R"(
+    {
+        "schema-version" : 1,
+        "template" : {
+            "category-layout" : "grid",
+            "card-size": "small"
+        },
+        "components" : {
+            "title" : "title",
+            "art" : {
+                "field": "art",
+                "aspect-ratio": 1.6,
+                "fill-mode": "fit"
+            }
+        }
+    }
+)";
+
+std::string CATEGORY_APPS_SEARCH = R"(
+    {
+        "schema-version" : 1,
+        "template" : {
+            "category-layout" : "grid",
+            "card-layout" : "horizontal",
+            "card-size": "large"
+        },
+        "components" : {
+            "title" : "title",
+            "mascot" : {
+                "field": "art"
+            },
+            "subtitle": "publisher"
+        }
+    }
+)";
+
+static const char CATEGORY_STORE[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "medium",
+    "card-background": "color:///#E9E9E9"
+  },
+  "components": {
+    "title": "title",
+    "subtitle": "author",
+    "mascot":  {
+         "field": "art"
+    },
+    "background": "background"
+  }
+}
+)";
+
+
+}
+
+void click::Query::push_local_results(scopes::SearchReplyProxy const &replyProxy,
+                                      std::vector<click::Application> const &apps,
+                                      std::string &categoryTemplate)
+{
+    scopes::CategoryRenderer rdr(categoryTemplate);
+    auto cat = replyProxy->register_category("local", "", "", rdr);
+
+    for(const auto & a: apps)
+    {
+        scopes::CategorisedResult res(cat);
+        res.set_title(a.title);
+        res.set_art(a.icon_url);
+        res.set_uri(a.url);
+        res[click::Query::ResultKeys::NAME] = a.name;
+        res[click::Query::ResultKeys::DESCRIPTION] = a.description;
+        res[click::Query::ResultKeys::MAIN_SCREENSHOT] = a.main_screenshot;
+        res[click::Query::ResultKeys::INSTALLED] = true;
+        res[click::Query::ResultKeys::VERSION] = a.version;
+        replyProxy->push(res);
+    }
+}
+
+struct click::Query::Private
+{
+    Private(const unity::scopes::CannedQuery& query, click::Index& index, const scopes::SearchMetadata& metadata)
+        : query(query),
+          index(index),
+          meta(metadata)
+    {
+    }
+    unity::scopes::CannedQuery query;
+    click::Index& index;
+    scopes::SearchMetadata meta;
+};
+
+click::Query::Query(unity::scopes::CannedQuery const& query, click::Index& index, scopes::SearchMetadata const& metadata)
+    : impl(new Private(query, index, metadata))
+{
+}
+
+void click::Query::cancelled()
+{
+    qDebug() << "cancelling search of" << QString::fromStdString(impl->query.query_string());
+}
+
+click::Query::~Query()
+{
+    qDebug() << "destroying search";
+}
+
+namespace
+{
+click::Interface& clickInterfaceInstance()
+{
+    static QSharedPointer<click::KeyFileLocator> keyFileLocator(new click::KeyFileLocator());
+    static click::Interface iface(keyFileLocator);
+
+    return iface;
+}
+
+}
+
+void click::Query::add_fake_store_app(scopes::SearchReplyProxy const& searchReply)
+{
+    static const std::string title = _("Get more apps in Ubuntu store");
+    auto name = title;
+
+    std::string query = impl->query.query_string();
+    std::transform(query.begin(), query.end(), query.begin(), ::tolower);
+    std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+    if (query.empty() || name.find(query) != std::string::npos)
+    {
+        scopes::CategoryRenderer rdr(CATEGORY_STORE);
+        auto cat = searchReply->register_category("store", "", "", rdr);
+
+        static const unity::scopes::CannedQuery store_scope("com.canonical.scopes.clickstore");
+
+        scopes::CategorisedResult res(cat);
+        res.set_title(title);
+        res.set_art(STORE_DATA_DIR "/apps-scope.svg");
+        res.set_uri(store_scope.to_uri());
+        res[click::Query::ResultKeys::NAME] = title;
+        res[click::Query::ResultKeys::DESCRIPTION] = "";
+        res[click::Query::ResultKeys::MAIN_SCREENSHOT] = "";
+        res[click::Query::ResultKeys::INSTALLED] = true;
+        res[click::Query::ResultKeys::VERSION] = "";
+        searchReply->push(res);
+    }
+}
+
+void click::Query::run(scopes::SearchReplyProxy const& searchReply)
+{
+    auto query = impl->query.query_string();
+    std::string categoryTemplate = CATEGORY_APPS_SEARCH;
+    if (query.empty()) {
+        categoryTemplate = CATEGORY_APPS_DISPLAY;
+    }
+    auto localResults = clickInterfaceInstance().find_installed_apps(
+                query);
+
+    // Sort applications so that newest come first.
+    std::sort(localResults.begin(), localResults.end(), [](const Application& a, const Application& b) {
+                  return a.installed_time > b.installed_time;
+                });
+
+    push_local_results(
+        searchReply,
+        localResults,
+        categoryTemplate);
+
+    add_fake_store_app(searchReply);
+}
 
=== added file 'scope/clickapps/apps-query.h'
--- scope/clickapps/apps-query.h	1970-01-01 00:00:00 +0000
+++ scope/clickapps/apps-query.h	2014-06-06 00:43:07 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef APPS_QUERY_H
+#define APPS_QUERY_H
+
+
+#include <unity/scopes/SearchQueryBase.h>
+
+namespace scopes = unity::scopes;
+
+#include <QSharedPointer>
+#include <set>
+
+
+namespace click
+{
+
+class Application;
+class Index;
+
+class Query : public scopes::SearchQueryBase
+{
+public:
+    struct ResultKeys
+    {
+        ResultKeys() = delete;
+
+        constexpr static const char* NAME{"name"};
+        constexpr static const char* DESCRIPTION{"description"};
+        constexpr static const char* MAIN_SCREENSHOT{"main_screenshot"};
+        constexpr static const char* INSTALLED{"installed"};
+        constexpr static const char* DOWNLOAD_URL{"download_url"};
+        constexpr static const char* VERSION{"version"};
+    };
+
+    Query(unity::scopes::CannedQuery const& query, click::Index& index, scopes::SearchMetadata const& metadata);
+    virtual ~Query();
+
+    virtual void cancelled() override;
+
+    virtual void run(scopes::SearchReplyProxy const& reply) override;
+
+protected:
+    virtual void add_fake_store_app(scopes::SearchReplyProxy const &replyProxy);
+    virtual void push_local_results(scopes::SearchReplyProxy const &replyProxy,
+                                    std::vector<click::Application> const &apps,
+                                    std::string& categoryTemplate);
+
+private:
+    struct Private;
+    QSharedPointer<Private> impl;
+};
+}
+
+#endif // CLICK_QUERY_H
 
=== added file 'scope/clickapps/apps-scope.cpp'
--- scope/clickapps/apps-scope.cpp	1970-01-01 00:00:00 +0000
+++ scope/clickapps/apps-scope.cpp	2014-06-06 00:43:07 +0000
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2014 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include <click/qtbridge.h>
+#include <click/preview.h>
+#include <click/interface.h>
+#include <click/scope_activation.h>
+
+#include <QSharedPointer>
+
+#include <click/key_file_locator.h>
+#include <click/network_access_manager.h>
+#include <click/click-i18n.h>
+#include <unity/scopes/CannedQuery.h>
+
+#include "apps-scope.h"
+#include "apps-query.h"
+
+namespace
+{
+click::Interface& clickInterfaceInstance()
+{
+    static QSharedPointer<click::KeyFileLocator> keyFileLocator(new click::KeyFileLocator());
+    static click::Interface iface(keyFileLocator);
+    return iface;
+}
+}
+
+click::Scope::Scope()
+{
+    nam.reset(new click::network::AccessManager());
+    client.reset(new click::web::Client(nam));
+    index.reset(new click::Index(client));
+}
+
+click::Scope::~Scope()
+{
+}
+
+int click::Scope::start(std::string const&, scopes::RegistryProxy const&)
+{
+    setlocale(LC_ALL, "");
+    bindtextdomain(GETTEXT_PACKAGE, GETTEXT_LOCALEDIR);
+    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+
+    return VERSION;
+}
+
+void click::Scope::run()
+{
+    static const int zero = 0;
+    auto emptyCb = [this]()
+    {
+    };
+
+    qt::core::world::build_and_run(zero, nullptr, emptyCb);
+}
+
+void click::Scope::stop()
+{
+    qt::core::world::destroy();
+}
+
+scopes::SearchQueryBase::UPtr click::Scope::search(unity::scopes::CannedQuery const& q, scopes::SearchMetadata const& metadata)
+{
+    return scopes::SearchQueryBase::UPtr(new click::Query(q, *index, metadata));
+}
+
+
+unity::scopes::PreviewQueryBase::UPtr click::Scope::preview(const unity::scopes::Result& result,
+        const unity::scopes::ActionMetadata& metadata) {
+    qDebug() << "Scope::preview() called.";
+    return scopes::PreviewQueryBase::UPtr{new click::Preview(result, metadata, client, nam)};
+}
+
+
+unity::scopes::ActivationQueryBase::UPtr click::Scope::perform_action(unity::scopes::Result const& result, unity::scopes::ActionMetadata const& metadata, std::string const& /* widget_id */, std::string const& action_id)
+{
+    if (action_id == click::Preview::Actions::CONFIRM_UNINSTALL) {
+        const unity::scopes::CannedQuery cquery("clickscope");
+        return scopes::ActivationQueryBase::UPtr(new PerformUninstallAction(result, unity::scopes::ActivationResponse(cquery)));
+    }
+
+    auto activation = new ScopeActivation();
+    qDebug() << "perform_action called with action_id" << QString().fromStdString(action_id);
+
+    if (action_id == click::Preview::Actions::UNINSTALL_CLICK) {
+        activation->setHint(click::Preview::Actions::UNINSTALL_CLICK, unity::scopes::Variant(true));
+        activation->setStatus(unity::scopes::ActivationResponse::Status::ShowPreview);
+    } else if (action_id == click::Preview::Actions::CLOSE_PREVIEW) {
+        activation->setHint(click::Preview::Actions::CLOSE_PREVIEW, unity::scopes::Variant(true));
+        activation->setStatus(unity::scopes::ActivationResponse::Status::ShowPreview);
+    } else if (action_id == click::Preview::Actions::RATED) {
+        scopes::VariantMap rating_info = metadata.scope_data().get_dict();
+        // Cast to int because widget gives us double, which is wrong.
+        int rating = ((int)rating_info["rating"].get_double());
+        std::string review_text = rating_info["review"].get_string();
+
+        // We have to get the values and then set them as hints here, to be
+        // able to pass them on to the Preview, which actually makes the
+        // call to submit.
+        activation->setHint("rating", scopes::Variant(rating));
+        activation->setHint("review", scopes::Variant(review_text));
+        activation->setHint(click::Preview::Actions::RATED,
+                            scopes::Variant(true));
+        activation->setStatus(scopes::ActivationResponse::Status::ShowPreview);
+    }
+    return scopes::ActivationQueryBase::UPtr(activation);
+}
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+extern "C"
+{
+
+    EXPORT
+    unity::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_CREATE_FUNCTION()
+    {
+        return new click::Scope();
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_DESTROY_FUNCTION(unity::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}
 
=== added file 'scope/clickapps/apps-scope.h'
--- scope/clickapps/apps-scope.h	1970-01-01 00:00:00 +0000
+++ scope/clickapps/apps-scope.h	2014-06-06 00:43:07 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2014 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef APPS_SCOPE_H
+#define APPS_SCOPE_H
+
+#include <click/network_access_manager.h>
+#include <click/webclient.h>
+
+#include <unity/scopes/ScopeBase.h>
+#include <unity/scopes/QueryBase.h>
+#include <unity/scopes/ActivationQueryBase.h>
+
+#include <click/index.h>
+
+namespace scopes = unity::scopes;
+
+namespace click
+{
+class Scope : public scopes::ScopeBase
+{
+public:
+    Scope();
+    ~Scope();
+
+    virtual int start(std::string const&, scopes::RegistryProxy const&) override;
+
+    virtual void run() override;
+    virtual void stop() override;
+
+    virtual scopes::SearchQueryBase::UPtr search(scopes::CannedQuery const& q, scopes::SearchMetadata const&) override;
+    unity::scopes::PreviewQueryBase::UPtr preview(const unity::scopes::Result&,
+            const unity::scopes::ActionMetadata&) override;
+
+    virtual unity::scopes::ActivationQueryBase::UPtr perform_action(unity::scopes::Result const& result, unity::scopes::ActionMetadata const& metadata, std::string const& widget_id, std::string const& action_id) override;
+
+private:
+    QSharedPointer<click::network::AccessManager> nam;
+    QSharedPointer<click::web::Client> client;
+    QSharedPointer<click::Index> index;
+
+    std::string installApplication(unity::scopes::Result const& result);
+};
+}
+#endif // CLICK_SCOPE_H
 
=== renamed directory 'scope/click' => 'scope/clickstore'
=== modified file 'scope/clickstore/CMakeLists.txt'
--- scope/click/CMakeLists.txt	2014-05-26 14:02:45 +0000
+++ scope/clickstore/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -8,19 +8,20 @@
   -DGETTEXT_LOCALEDIR=\"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LOCALEDIR}\"
 )
 
-add_library(${SCOPE_LIB_UNVERSIONED} SHARED
-  query.cpp
-  scope.cpp
+add_library(${STORE_LIB_UNVERSIONED} SHARED
+  store-query.cpp
+  store-scope.cpp
 )
+set_target_properties(${STORE_LIB_UNVERSIONED} PROPERTIES PREFIX "")
 
 include_directories(
   ${CMAKE_SOURCE_DIR}/libclickscope
   ${JSON_CPP_INCLUDE_DIRS}
 )
 
-qt5_use_modules (${SCOPE_LIB_UNVERSIONED} Network)
+qt5_use_modules (${STORE_LIB_UNVERSIONED} Network)
 
-target_link_libraries (${SCOPE_LIB_UNVERSIONED}
+target_link_libraries (${STORE_LIB_UNVERSIONED}
   ${SCOPE_LIB_NAME}
   ${JSON_CPP_LDFLAGS}
   ${UNITY_SCOPES_LDFLAGS}
@@ -30,6 +31,6 @@
 )
 
 install(
-  TARGETS ${SCOPE_LIB_UNVERSIONED}
-  LIBRARY DESTINATION "${SCOPE_LIB_DIR}"
+  TARGETS ${STORE_LIB_UNVERSIONED}
+  LIBRARY DESTINATION "${STORE_LIB_DIR}"
   )
 
=== renamed file 'scope/click/query.cpp' => 'scope/clickstore/store-query.cpp'
--- scope/click/query.cpp	2014-05-26 14:02:45 +0000
+++ scope/clickstore/store-query.cpp	2014-06-06 00:43:07 +0000
@@ -28,9 +28,9 @@
  */
 
 #include <click/application.h>
-#include "query.h"
+#include <click/interface.h>
+#include "store-query.h"
 #include <click/qtbridge.h>
-#include <click/interface.h>
 
 #include <click/key_file_locator.h>
 
@@ -48,6 +48,8 @@
 
 #include <click/click-i18n.h>
 
+using namespace click;
+
 namespace
 {
 
@@ -60,10 +62,10 @@
         },
         "components" : {
             "title" : "title",
+            "subtitle": "subtitle",
             "art" : {
                 "field": "art",
-                "aspect-ratio": 1.6,
-                "fill-mode": "fit"
+                "aspect-ratio": 1.13
             }
         }
     }
@@ -89,32 +91,6 @@
 
 }
 
-void click::Query::push_local_results(scopes::SearchReplyProxy const &replyProxy,
-                                      std::vector<click::Application> const &apps,
-                                      std::string &categoryTemplate)
-{
-    scopes::CategoryRenderer rdr(categoryTemplate);
-    auto cat = replyProxy->register_category("local", _("My apps"), "", rdr);
-
-    // cat might be null when the underlying query got cancelled.
-    if (!cat)
-        return;
-
-    for(const auto & a: apps)
-    {
-        scopes::CategorisedResult res(cat);
-        res.set_title(a.title);
-        res.set_art(a.icon_url);
-        res.set_uri(a.url);
-        res[click::Query::ResultKeys::NAME] = a.name;
-        res[click::Query::ResultKeys::DESCRIPTION] = a.description;
-        res[click::Query::ResultKeys::MAIN_SCREENSHOT] = a.main_screenshot;
-        res[click::Query::ResultKeys::INSTALLED] = true;
-        res[click::Query::ResultKeys::VERSION] = a.version;
-        replyProxy->push(res);
-    }
-}
-
 struct click::Query::Private
 {
     Private(const unity::scopes::CannedQuery& query, click::Index& index, const scopes::SearchMetadata& metadata)
@@ -145,9 +121,7 @@
     impl->search_operation.cancel();
 }
 
-namespace
-{
-click::Interface& clickInterfaceInstance()
+click::Interface& click::Query::clickInterfaceInstance()
 {
     static QSharedPointer<click::KeyFileLocator> keyFileLocator(new click::KeyFileLocator());
     static click::Interface iface(keyFileLocator);
@@ -155,8 +129,6 @@
     return iface;
 }
 
-}
-
 bool click::Query::push_result(scopes::SearchReplyProxy const& searchReply, const scopes::CategorisedResult &res)
 {
     return searchReply->push(res);
@@ -184,7 +156,7 @@
 }
 
 void click::Query::add_available_apps(scopes::SearchReplyProxy const& searchReply,
-                                      const std::set<std::string>& locallyInstalledApps,
+                                      const PackageNames& installedPackages,
                                       const std::string& categoryTemplate)
 {
     scopes::CategoryRenderer categoryRenderer(categoryTemplate);
@@ -197,7 +169,7 @@
 
     run_under_qt([=]()
     {
-            auto search_cb = [this, searchReply, category, locallyInstalledApps](PackageList packages) {
+            auto search_cb = [this, searchReply, category, installedPackages](PackageList packages) {
                 qDebug("search callback");
 
                 // handle packages data
@@ -205,15 +177,13 @@
                     qDebug() << "pushing result" << QString::fromStdString(p.name);
                     try {
                         scopes::CategorisedResult res(category);
-                        if (locallyInstalledApps.count(p.name) > 0) {
-                            qDebug() << "already installed" << QString::fromStdString(p.name);
-                            continue;
-                        }
                         res.set_title(p.title);
                         res.set_art(p.icon_url);
                         res.set_uri(p.url);
                         res[click::Query::ResultKeys::NAME] = p.name;
-                        res[click::Query::ResultKeys::INSTALLED] = false;
+                        bool installed = (installedPackages.count(p.name) > 0);
+                        res[click::Query::ResultKeys::INSTALLED] = installed;
+                        res["subtitle"] = installed ? "✔ Installed" : "FREE";
 
                         this->push_result(searchReply, res);
                     } catch(const std::exception& e){
@@ -231,6 +201,23 @@
     });
 }
 
+PackageNames click::Query::get_installed_packages()
+{
+    std::promise<PackageNames> installed_promise;
+    std::future<PackageNames> installed_future = installed_promise.get_future();
+
+    run_under_qt([&]()
+    {
+        clickInterfaceInstance().get_installed_packagenames(
+                    [&installed_promise](PackageNames installedPackages, InterfaceError){
+            installed_promise.set_value(installedPackages);
+        });
+    });
+
+    return installed_future.get();
+}
+
+
 void click::Query::run(scopes::SearchReplyProxy const& searchReply)
 {
     auto query = impl->query.query_string();
@@ -238,18 +225,6 @@
     if (query.empty()) {
         categoryTemplate = CATEGORY_APPS_DISPLAY;
     }
-    auto localResults = clickInterfaceInstance().find_installed_apps(
-                query);
-
-    push_local_results(
-        searchReply, 
-        localResults,
-        categoryTemplate);
-
-    std::set<std::string> locallyInstalledApps;
-    for(const auto& app : localResults) {
-        locallyInstalledApps.insert(app.name);
-    }
 
     static const std::string no_net_hint("no-internet");
     if (impl->meta.contains_hint(no_net_hint))
@@ -259,8 +234,7 @@
         {
             return;
         }
-
     }
 
-    add_available_apps(searchReply, locallyInstalledApps, categoryTemplate);
+    add_available_apps(searchReply, get_installed_packages(), categoryTemplate);
 }
 
=== renamed file 'scope/click/query.h' => 'scope/clickstore/store-query.h'
--- scope/click/query.h	2014-05-14 18:34:20 +0000
+++ scope/clickstore/store-query.h	2014-06-06 00:43:07 +0000
@@ -27,8 +27,8 @@
  * files in the program, then also delete it here.
  */
 
-#ifndef CLICK_QUERY_H
-#define CLICK_QUERY_H
+#ifndef STORE_QUERY_H
+#define STORE_QUERY_H
 
 
 #include <unity/scopes/SearchQueryBase.h>
@@ -36,8 +36,8 @@
 namespace scopes = unity::scopes;
 
 #include <QSharedPointer>
-#include <set>
-
+#include <unordered_set>
+#include <click/interface.h>
 
 namespace click
 {
@@ -78,12 +78,11 @@
     virtual void run(scopes::SearchReplyProxy const& reply) override;
 
 protected:
-    virtual void add_available_apps(const scopes::SearchReplyProxy &searchReply, const std::set<std::string> &locallyInstalledApps, const std::string &category);
+    virtual void add_available_apps(const scopes::SearchReplyProxy &searchReply, const PackageNames &installedPackages, const std::string &category);
+    virtual click::Interface& clickInterfaceInstance();
+    virtual PackageNames get_installed_packages();
     virtual bool push_result(const scopes::SearchReplyProxy &searchReply, scopes::CategorisedResult const& res);
     virtual void finished(const scopes::SearchReplyProxy &searchReply);
-    virtual void push_local_results(scopes::SearchReplyProxy const &replyProxy,
-                                    std::vector<click::Application> const &apps,
-                                    std::string& categoryTemplate);
     virtual scopes::Category::SCPtr register_category(scopes::SearchReplyProxy const& searchReply,
                                                std::string const& id,
                                                std::string const& title,
 
=== renamed file 'scope/click/scope.cpp' => 'scope/clickstore/store-scope.cpp'
--- scope/click/scope.cpp	2014-05-27 08:30:21 +0000
+++ scope/clickstore/store-scope.cpp	2014-06-06 00:43:07 +0000
@@ -28,8 +28,8 @@
  */
 
 #include <click/qtbridge.h>
-#include "scope.h"
-#include "query.h"
+#include "store-scope.h"
+#include "store-query.h"
 #include <click/preview.h>
 #include <click/interface.h>
 #include <click/scope_activation.h>
 
=== renamed file 'scope/click/scope.h' => 'scope/clickstore/store-scope.h'
=== modified file 'scope/tests/CMakeLists.txt'
--- scope/tests/CMakeLists.txt	2014-05-26 14:27:31 +0000
+++ scope/tests/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -22,7 +22,7 @@
 qt5_use_modules(${CLICKSCOPE_TESTS_TARGET} Core DBus Network Test)
 
 target_link_libraries(${CLICKSCOPE_TESTS_TARGET}
-  ${SCOPE_LIB_UNVERSIONED}
+  ${STORE_LIB_UNVERSIONED}
   ${SCOPE_LIB_NAME}
 
   ${UNITY_SCOPES_LDFLAGS}
 
=== modified file 'scope/tests/click_interface_tool/CMakeLists.txt'
--- scope/tests/click_interface_tool/CMakeLists.txt	2014-05-13 19:32:29 +0000
+++ scope/tests/click_interface_tool/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -10,5 +10,5 @@
 )
 
 target_link_libraries (${CLICK_INTERFACE_TOOL_TARGET}
-  ${SCOPE_LIB_UNVERSIONED}
+  ${STORE_LIB_UNVERSIONED}
 )
 
=== modified file 'scope/tests/click_interface_tool/click_interface_tool.cpp'
--- scope/tests/click_interface_tool/click_interface_tool.cpp	2014-05-13 19:32:29 +0000
+++ scope/tests/click_interface_tool/click_interface_tool.cpp	2014-06-06 00:43:07 +0000
@@ -51,8 +51,8 @@
 
     QObject::connect(&timer, &QTimer::timeout, [&]() {
             ci.get_dotdesktop_filename(std::string(argv[1]),
-                                       [&a] (std::string val, click::ManifestError error){
-                                           if (error == click::ManifestError::NoError) {
+                                       [&a] (std::string val, click::InterfaceError error){
+                                           if (error == click::InterfaceError::NoError) {
                                                std::cout << " Success, got dotdesktop:" << val << std::endl;
                                            } else {
                                                std::cout << " Error:" << val << std::endl;
 
=== modified file 'scope/tests/download_manager_tool/CMakeLists.txt'
--- scope/tests/download_manager_tool/CMakeLists.txt	2014-02-27 17:24:07 +0000
+++ scope/tests/download_manager_tool/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -10,5 +10,5 @@
 )
 
 target_link_libraries (${DOWNLOAD_MANAGER_TOOL_TARGET}
-  ${SCOPE_LIB_UNVERSIONED}
+  ${STORE_LIB_UNVERSIONED}
 )
 
=== modified file 'scope/tests/integration/CMakeLists.txt'
--- scope/tests/integration/CMakeLists.txt	2014-02-27 17:24:07 +0000
+++ scope/tests/integration/CMakeLists.txt	2014-06-06 00:43:07 +0000
@@ -17,7 +17,7 @@
 qt5_use_modules(${INTEGRATION_TARGET} Core DBus Network Test)
 
 target_link_libraries (${INTEGRATION_TARGET}
-  ${SCOPE_LIB_UNVERSIONED}
+  ${STORE_LIB_UNVERSIONED}
 
   gmock
   gmock_main
 
=== modified file 'scope/tests/test_query.cpp'
--- scope/tests/test_query.cpp	2014-05-21 13:42:45 +0000
+++ scope/tests/test_query.cpp	2014-06-06 00:43:07 +0000
@@ -34,7 +34,7 @@
 #include <gmock/gmock.h>
 
 #include "click/qtbridge.h"
-#include "click/query.h"
+#include "clickstore/store-query.h"
 #include "click/index.h"
 #include "click/application.h"
 
@@ -47,6 +47,7 @@
 #include <unity/scopes/SearchReply.h>
 
 using namespace ::testing;
+using namespace click;
 
 namespace
 {
@@ -98,18 +99,20 @@
 
     }
     void wrap_add_available_apps(const scopes::SearchReplyProxy &searchReply,
-                                 const std::set<std::string> &locallyInstalledApps,
+                                 const PackageNames &installedPackages,
                                  const std::string& categoryTemplate)
     {
-        add_available_apps(searchReply, locallyInstalledApps, categoryTemplate);
+        add_available_apps(searchReply, installedPackages, categoryTemplate);
     }
     MOCK_METHOD2(push_result, bool(scopes::SearchReplyProxy const&, scopes::CategorisedResult const&));
+    MOCK_METHOD0(clickInterfaceInstance, click::Interface&());
     MOCK_METHOD1(finished, void(scopes::SearchReplyProxy const&));
     MOCK_METHOD5(register_category, scopes::Category::SCPtr(const scopes::SearchReplyProxy &searchReply,
                                                             const std::string &id,
                                                             const std::string &title,
                                                             const std::string &icon,
                                                             const scopes::CategoryRenderer &renderer_template));
+    using click::Query::get_installed_packages; // allow tests to access protected method
 };
 
 class MockQueryRun : public MockQueryBase {
@@ -121,11 +124,12 @@
     }
     MOCK_METHOD3(add_available_apps,
                  void(scopes::SearchReplyProxy const&searchReply,
-                      const std::set<std::string> &locallyInstalledApps,
+                      const PackageNames &locallyInstalledApps,
                       const std::string& categoryTemplate));
     MOCK_METHOD3(push_local_results, void(scopes::SearchReplyProxy const &replyProxy,
                                           std::vector<click::Application> const &apps,
                                           std::string& categoryTemplate));
+    MOCK_METHOD0(get_installed_packages, PackageNames());
 };
 
 class FakeCategory : public scopes::Category
@@ -144,7 +148,7 @@
 {
     MockIndex mock_index;
     scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> no_installed_packages;
+    PackageNames no_installed_packages;
     const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
     MockQuery q(query, mock_index, metadata);
     EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _)).Times(1);
@@ -163,7 +167,7 @@
     };
     MockIndex mock_index(packages);
     scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> no_installed_packages;
+    PackageNames no_installed_packages;
     const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
     MockQuery q(query, mock_index, metadata);
     EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _));
@@ -185,7 +189,7 @@
     };
     MockIndex mock_index(packages);
     scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> no_installed_packages;
+    PackageNames no_installed_packages;
     const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
     MockQuery q(query, mock_index, metadata);
     EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _));
@@ -206,7 +210,7 @@
     };
     MockIndex mock_index(packages);
     scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> no_installed_packages;
+    PackageNames no_installed_packages;
     const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
     MockQuery q(query, mock_index, metadata);
     EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _)).Times(0);
@@ -225,39 +229,94 @@
     };
     MockIndex mock_index(packages);
     scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> no_installed_packages;
+    PackageNames no_installed_packages;
     const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
     MockQueryRun q(query, mock_index, metadata);
     auto reply = scopes::SearchReplyProxy();
-    EXPECT_CALL(q, push_local_results(_, _, _));
+    EXPECT_CALL(q, get_installed_packages()).WillOnce(Return(no_installed_packages));
     EXPECT_CALL(q, add_available_apps(reply, no_installed_packages, _));
 
     q.run(reply);
 }
 
 MATCHER_P(HasPackageName, n, "") { return arg[click::Query::ResultKeys::NAME].get_string() == n; }
-
-TEST(QueryTest, testDuplicatesFilteredOnPackageName)
-{
-    click::PackageList packages {
-        {"org.example.app1", "app title1", 0.0, "icon", "uri"},
-        {"org.example.app2", "app title2", 0.0, "icon", "uri"}
-    };
-    MockIndex mock_index(packages);
-    scopes::SearchMetadata metadata("en_EN", "phone");
-    std::set<std::string> one_installed_package {
-        "org.example.app2"
-    };
-    const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
-    MockQuery q(query, mock_index, metadata);
-    EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _));
-
-    scopes::CategoryRenderer renderer("{}");
-    auto ptrCat = std::make_shared<FakeCategory>("id", "", "", renderer);
-    EXPECT_CALL(q, register_category(_, _, _, _, _)).WillOnce(Return(ptrCat));
-
-    scopes::SearchReplyProxy reply;
-    auto expected_name = packages.front().name;
-    EXPECT_CALL(q, push_result(_, HasPackageName(expected_name)));
-    q.wrap_add_available_apps(reply, one_installed_package, FAKE_CATEGORY_TEMPLATE);
+MATCHER_P(IsInstalled, b, "") { return arg[click::Query::ResultKeys::INSTALLED].get_bool() == b; }
+
+TEST(QueryTest, testDuplicatesNotFilteredAnymore)
+{
+    click::PackageList packages {
+        {"org.example.app1", "app title1", 0.0, "icon", "uri"},
+        {"org.example.app2", "app title2", 0.0, "icon", "uri"}
+    };
+    MockIndex mock_index(packages);
+    scopes::SearchMetadata metadata("en_EN", "phone");
+    PackageNames one_installed_package {
+        "org.example.app2"
+    };
+    const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
+    MockQuery q(query, mock_index, metadata);
+    EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _));
+
+    scopes::CategoryRenderer renderer("{}");
+    auto ptrCat = std::make_shared<FakeCategory>("id", "", "", renderer);
+    EXPECT_CALL(q, register_category(_, _, _, _, _)).WillOnce(Return(ptrCat));
+
+    scopes::SearchReplyProxy reply;
+    auto expected_name1 = packages.front().name;
+    EXPECT_CALL(q, push_result(_, HasPackageName(expected_name1)));
+    auto expected_name2 = packages.back().name;
+    EXPECT_CALL(q, push_result(_, HasPackageName(expected_name2)));
+    q.wrap_add_available_apps(reply, one_installed_package, FAKE_CATEGORY_TEMPLATE);
+}
+
+TEST(QueryTest, testInstalledPackagesFlaggedAsSuch)
+{
+    click::PackageList packages {
+        {"org.example.app1", "app title1", 0.0, "icon", "uri"},
+        {"org.example.app2", "app title2", 0.0, "icon", "uri"}
+    };
+    MockIndex mock_index(packages);
+    scopes::SearchMetadata metadata("en_EN", "phone");
+    PackageNames one_installed_package {
+        "org.example.app2"
+    };
+    const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
+    MockQuery q(query, mock_index, metadata);
+    EXPECT_CALL(mock_index, do_search(FAKE_QUERY, _));
+
+    scopes::CategoryRenderer renderer("{}");
+    auto ptrCat = std::make_shared<FakeCategory>("id", "", "", renderer);
+    EXPECT_CALL(q, register_category(_, _, _, _, _)).WillOnce(Return(ptrCat));
+
+    scopes::SearchReplyProxy reply;
+    EXPECT_CALL(q, push_result(_, IsInstalled(true)));
+    EXPECT_CALL(q, push_result(_, IsInstalled(false)));
+    q.wrap_add_available_apps(reply, one_installed_package, FAKE_CATEGORY_TEMPLATE);
+}
+
+class FakeInterface : public click::Interface
+{
+public:
+    MOCK_METHOD1(get_installed_packagenames, void(std::function<void(PackageNames, click::InterfaceError)> callback));
+};
+
+TEST(QueryTest, testGetInstalledPackages)
+{
+    click::PackageList uninstalled_packages {
+        {"name", "title", 0.0, "icon", "uri"}
+    };
+    MockIndex mock_index(uninstalled_packages);
+    scopes::SearchMetadata metadata("en_EN", "phone");
+    const unity::scopes::CannedQuery query("foo.scope", FAKE_QUERY, "");
+    MockQuery q(query, mock_index, metadata);
+    PackageNames installed_packages{"package_1"};
+
+    FakeInterface fake_interface;
+    EXPECT_CALL(q, clickInterfaceInstance()).WillOnce(ReturnRef(fake_interface));
+    EXPECT_CALL(fake_interface, get_installed_packagenames(_)).WillOnce(Invoke(
+        [&](std::function<void(PackageNames, click::InterfaceError)> callback){
+            callback(installed_packages, click::InterfaceError::NoError);
+    }));
+
+    ASSERT_EQ(q.get_installed_packages(), installed_packages);
 }