Merge lp:~ted/ubuntu-app-launch/app-store into lp:ubuntu-app-launch

[Ted Gould]

Put all application specific static functions into a single AppStore object

This moves the growing collection of static functions that were starting to collect in the application implementations which were causing a whole set of problems. This creates an app store backend for each type, that exists throughout the lifecycle of the registry itself.

Here we end up fixing quite a few problems, and delete some really ugly code. We end up hiding almost all the implementations to any of the higher level code. And we have a possibility to inject an AppStore mock in for more precise testing.

I think that, if we didn't count copyright headers and #includes, this branch would actually reduce the amount of code as well.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:302
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/237/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1730/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1737
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1512
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1512/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1512/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1512
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1512/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1512/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1512
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1512/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1512/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/237/rebuild

review: Needs Fixing (continuous-integration)

[Charles Kerr (charlesk)]

This is a nice improvement! Moving away from the static methods is a good cleanup. Thanks for doing this.

Inline are more minor cleanup suggestions. Most of them are in moved code rather than new code. The new code LGTM

review: Approve

[Ted Gould (ted)]

On Tue, 2017-03-14 at 03:55 +0000, Charles Kerr wrote:
> Inline are more minor cleanup suggestions. Most of them are in moved
> code rather than new code. The new code LGTM
So I'm going to ignore a bunch of these because they're in code that
gets deleted real soon, and I'm lazy :-)
> > +/** Looks for an application by looking through the system and user
> > + application directories to find the desktop file.
> > +
> > + \param package Container name
> > + \param appname Application name to look for
> > + \param registry persistent connections to use
> > +*/
> > +bool Legacy::verifyAppname(const AppID::Package& package,
> > + const AppID::AppName& appname,
> > + const std::shared_ptr<Registry>& registry)
> > +{
> > + if (!verifyPackage(package, registry))
> > + {
> > + throw std::runtime_error{"Invalid Legacy package: " + std::string(package)};
> > + }
> > +
> > + auto desktop = std::string(appname) + ".desktop";
> > + auto evaldir = [&desktop](const gchar* dir) -> bool {
> >

>
>
> "-> bool" should be unnecessary; there's only one return point so g++ should be able to deduce the return type
>

Fixed r303. But you can't have this an the "return TRUE" below :-)
> > + if (evaldir(g_get_user_data_dir()))
> > + {
> > + return true;
> > + }
> > +
> > + const char* const* data_dirs = g_get_system_data_dirs();
> >

>
> auto&& data_dirs = g_get_system_data_dirs()
>

r304, cool, wouldn't have guessed that would have worked :-)

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:304
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/256/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1780/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1787
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1563
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1563/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1563
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1563/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1563
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1563/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1563
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1563/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1563/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1563/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/256/rebuild

review: Needs Fixing (continuous-integration)

[Charles Kerr (charlesk)]

>> auto&& data_dirs = g_get_system_data_dirs()

> r304, cool, wouldn't have guessed that would have worked :-)

Universal references were introducd in c++11 and we don't use them enough, myself included. It takes a bit of reading to understand what's going them, but the upside is that they're simple to write and generally Do The Right Thing. A much lower bar on esoteric features than, say, variadic templates :-)

First: http://thbecker.net/articles/rvalue_references/section_01.html

Then: https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers

[Charles Kerr (charlesk)]

review: Approve

=== modified file 'docs/Doxyfile'
--- docs/Doxyfile	2016-04-07 16:01:30 +0000
+++ docs/Doxyfile	2017-03-18 19:37:40 +0000
@@ -796,7 +796,7 @@
 # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f, *.for, *.tcl,
 # *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
 
-FILE_PATTERNS          =
+FILE_PATTERNS          = *.cpp *.h *.cc
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -811,7 +811,7 @@
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = libubuntu-app-launch/ubuntu-app-launch.h libubuntu-app-launch/ubuntu-app-launch.cpp
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

=== modified file 'docs/index.rst'
--- docs/index.rst	2017-01-31 21:34:10 +0000
+++ docs/index.rst	2017-03-18 19:37:40 +0000
@@ -186,6 +186,56 @@
    :private-members:
    :undoc-members:
 
+Application Storage Base
+------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_store::Base
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Application Storage Click
+-------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_store::Click
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Application Storage Legacy
+--------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_store::Legacy
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Application Storage Libertine
+-----------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_store::Libertine
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Application Storage Snap
+------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_store::Snap
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Helper Implementation Click
 ---------------------------
 

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2017-03-18 19:37:40 +0000
@@ -35,6 +35,16 @@
 
 set(LAUNCHER_CPP_SOURCES
 application.cpp
+app-store-base.h
+app-store-base.cpp
+app-store-click.h
+app-store-click.cpp
+app-store-legacy.h
+app-store-legacy.cpp
+app-store-libertine.h
+app-store-libertine.cpp
+app-store-snap.h
+app-store-snap.cpp
 helper.cpp
 registry.cpp
 registry-impl.h

=== added file 'libubuntu-app-launch/app-store-base.cpp'
--- libubuntu-app-launch/app-store-base.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-base.cpp	2017-03-18 19:37:40 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include "app-store-base.h"
+#include "app-store-click.h"
+#include "app-store-legacy.h"
+#include "app-store-libertine.h"
+
+#if ENABLE_SNAPPY
+#include "app-store-snap.h"
+#endif
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+Base::Base()
+    : info_watcher::Base({})
+{
+}
+
+Base::~Base()
+{
+}
+
+std::list<std::shared_ptr<Base>> Base::allAppStores()
+{
+    return
+    {
+        std::make_shared<Click>() /* Click */
+            ,
+            std::make_shared<Legacy>() /* Legacy */
+            ,
+            std::make_shared<Libertine>() /* Libertine */
+#if ENABLE_SNAPPY
+            ,
+            std::make_shared<Snap>() /* Snappy */
+#endif
+    };
+}
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-base.h'
--- libubuntu-app-launch/app-store-base.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-base.h	2017-03-18 19:37:40 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "appid.h"
+#include "application-impl-base.h"
+#include "info-watcher.h"
+#include "registry.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+class Base : public info_watcher::Base
+{
+public:
+    Base();
+    virtual ~Base();
+
+    /* Discover tools */
+    virtual bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) = 0;
+    virtual bool verifyAppname(const AppID::Package& package,
+                               const AppID::AppName& appname,
+                               const std::shared_ptr<Registry>& registry) = 0;
+    virtual AppID::AppName findAppname(const AppID::Package& package,
+                                       AppID::ApplicationWildcard card,
+                                       const std::shared_ptr<Registry>& registry) = 0;
+    virtual AppID::Version findVersion(const AppID::Package& package,
+                                       const AppID::AppName& appname,
+                                       const std::shared_ptr<Registry>& registry) = 0;
+    virtual bool hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) = 0;
+
+    /* Possible apps */
+    virtual std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry) = 0;
+
+    /* Application Creation */
+    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid, const std::shared_ptr<Registry>& registry) = 0;
+
+    /* Static get all */
+    static std::list<std::shared_ptr<Base>> allAppStores();
+};
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-click.cpp'
--- libubuntu-app-launch/app-store-click.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-click.cpp	2017-03-18 19:37:40 +0000
@@ -0,0 +1,248 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include "app-store-click.h"
+#include "application-impl-click.h"
+#include "registry-impl.h"
+
+#include <algorithm>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+std::list<AppID::AppName> manifestApps(const std::shared_ptr<JsonObject>& manifest);
+AppID::Version manifestVersion(const std::shared_ptr<JsonObject>& manifest);
+
+Click::Click()
+{
+}
+
+Click::~Click()
+{
+}
+
+/** Tries to get the Click manifest for a package. If it can successfully
+    get the manifest returns true.
+
+    \param package Name of the package
+    \param registry Persistent connections to use
+*/
+bool Click::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    return registry->impl->getClickManifest(package) != nullptr;
+}
+
+/** Verifies the applicaiton name by getting the list of applications
+    in the package manifest and seeing if the appname is in the list.
+
+    \param package Name of the package
+    \param appname Name of the application
+    \param registry Persistent connections to use
+*/
+bool Click::verifyAppname(const AppID::Package& package,
+                          const AppID::AppName& appname,
+                          const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    auto apps = manifestApps(manifest);
+
+    return std::find_if(apps.begin(), apps.end(), [&appname](const AppID::AppName& listApp) -> bool {
+               return appname.value() == listApp.value();
+           }) != apps.end();
+}
+
+/** Finds an application name based on a wildcard search. Gets the list
+    from the manifest, and then returns a value from that list.
+
+    \param package Name of the package
+    \param card Wildcard to search as
+    \param registry Persistent connections to use
+*/
+AppID::AppName Click::findAppname(const AppID::Package& package,
+                                  AppID::ApplicationWildcard card,
+                                  const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    auto apps = manifestApps(manifest);
+
+    if (apps.empty())
+    {
+        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
+    }
+
+    switch (card)
+    {
+        case AppID::ApplicationWildcard::FIRST_LISTED:
+            return *apps.begin();
+        case AppID::ApplicationWildcard::LAST_LISTED:
+            return *apps.rbegin();
+        case AppID::ApplicationWildcard::ONLY_LISTED:
+            if (apps.size() != 1)
+            {
+                throw std::runtime_error("More than a single app in package '" + package.value() +
+                                         "' when requested to find only app");
+            }
+            return *apps.begin();
+    }
+
+    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
+}
+
+/** Find the version of a package that that is requested
+
+    \param package Name of the package
+    \param appname Name of the application (not used)
+    \param registry Persistent connections to use
+*/
+AppID::Version Click::findVersion(const AppID::Package& package,
+                                  const AppID::AppName& appname,
+                                  const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    return manifestVersion(manifest);
+}
+
+/** Check to see if this AppID has a desktop file that is in our link
+    farm built by Click. Click puts a symoblic link there for every
+    valid AppID.
+
+    \param appid Application ID to check
+    \param registry Persistent connections to use
+*/
+bool Click::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    std::string appiddesktop = std::string(appid) + ".desktop";
+    gchar* click_link = nullptr;
+    const gchar* link_farm_dir = g_getenv("UBUNTU_APP_LAUNCH_LINK_FARM");
+    if (G_LIKELY(link_farm_dir == nullptr))
+    {
+        click_link =
+            g_build_filename(g_get_user_cache_dir(), "ubuntu-app-launch", "desktop", appiddesktop.c_str(), NULL);
+    }
+    else
+    {
+        click_link = g_build_filename(link_farm_dir, appiddesktop.c_str(), NULL);
+    }
+
+    bool click = g_file_test(click_link, G_FILE_TEST_EXISTS);
+    g_free(click_link);
+
+    return click;
+}
+
+std::list<std::shared_ptr<Application>> Click::list(const std::shared_ptr<Registry>& registry)
+{
+    std::list<std::shared_ptr<Application>> applist;
+
+    try
+    {
+        for (auto pkg : registry->impl->getClickPackages())
+        {
+            try
+            {
+                auto manifest = registry->impl->getClickManifest(pkg);
+
+                for (auto appname : manifestApps(manifest))
+                {
+                    try
+                    {
+                        AppID appid{pkg, appname, manifestVersion(manifest)};
+                        auto app = std::make_shared<app_impls::Click>(appid, manifest, registry);
+                        applist.emplace_back(app);
+                    }
+                    catch (std::runtime_error& e)
+                    {
+                        g_debug("Unable to create Click for application '%s' in package '%s': %s",
+                                appname.value().c_str(), pkg.value().c_str(), e.what());
+                    }
+                }
+            }
+            catch (std::runtime_error& e)
+            {
+                g_debug("Unable to get information to build Click app on package '%s': %s", pkg.value().c_str(),
+                        e.what());
+            }
+        }
+    }
+    catch (std::runtime_error& e)
+    {
+        g_debug("Unable to get packages from Click database: %s", e.what());
+    }
+
+    return applist;
+}
+
+std::shared_ptr<app_impls::Base> Click::create(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    return std::make_shared<app_impls::Click>(appid, registry);
+}
+
+std::list<AppID::AppName> manifestApps(const std::shared_ptr<JsonObject>& manifest)
+{
+    JsonObject* hooks = nullptr;
+    if (!json_object_has_member(manifest.get(), "hooks") ||
+        (hooks = json_object_get_object_member(manifest.get(), "hooks")) == nullptr)
+    {
+        throw std::runtime_error("Manifest does not have a 'hooks' field: " + Registry::Impl::printJson(manifest));
+    }
+
+    auto gapps = json_object_get_members(hooks);
+    if (gapps == nullptr)
+    {
+        throw std::runtime_error("GLib JSON confusion, please talk to your library vendor");
+    }
+
+    std::list<AppID::AppName> apps;
+
+    for (GList* item = gapps; item != nullptr; item = g_list_next(item))
+    {
+        auto appname = (const gchar*)item->data;
+
+        auto hooklist = json_object_get_object_member(hooks, appname);
+
+        if (json_object_has_member(hooklist, "desktop") == TRUE)
+        {
+            apps.emplace_back(AppID::AppName::from_raw(appname));
+        }
+    }
+
+    g_list_free(gapps);
+    return apps;
+}
+
+AppID::Version manifestVersion(const std::shared_ptr<JsonObject>& manifest)
+{
+    const gchar* cstr = nullptr;
+    if (!json_object_has_member(manifest.get(), "version") ||
+        (cstr = json_object_get_string_member(manifest.get(), "version")) == nullptr)
+    {
+        throw std::runtime_error("Unable to find version number in manifest: " + Registry::Impl::printJson(manifest));
+    }
+
+    auto cppstr = AppID::Version::from_raw(cstr);
+    return cppstr;
+}
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-click.h'
--- libubuntu-app-launch/app-store-click.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-click.h	2017-03-18 19:37:40 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "app-store-base.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+class Click : public Base
+{
+public:
+    Click();
+    virtual ~Click();
+
+    /* Discover tools */
+    virtual bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) override;
+    virtual bool verifyAppname(const AppID::Package& package,
+                               const AppID::AppName& appname,
+                               const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::AppName findAppname(const AppID::Package& package,
+                                       AppID::ApplicationWildcard card,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::Version findVersion(const AppID::Package& package,
+                                       const AppID::AppName& appname,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual bool hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) override;
+
+    /* Possible apps */
+    virtual std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry) override;
+
+    /* Application Creation */
+    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid,
+                                                    const std::shared_ptr<Registry>& registry) override;
+};
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-legacy.cpp'
--- libubuntu-app-launch/app-store-legacy.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-legacy.cpp	2017-03-18 19:37:40 +0000
@@ -0,0 +1,202 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include "app-store-legacy.h"
+#include "application-impl-legacy.h"
+
+#include <regex>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+Legacy::Legacy()
+{
+}
+
+Legacy::~Legacy()
+{
+}
+
+/** Checks the AppID by ensuring the version and package are empty
+    then looks for the application.
+
+    \param appid AppID to check
+    \param registry persistent connections to use
+*/
+bool Legacy::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        if (!appid.version.value().empty())
+        {
+            return false;
+        }
+
+        return verifyAppname(appid.package, appid.appname, registry);
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+/** Ensure the package is empty
+
+    \param package Container name
+    \param registry persistent connections to use
+*/
+bool Legacy::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    return package.value().empty();
+}
+
+/** Looks for an application by looking through the system and user
+    application directories to find the desktop file.
+
+    \param package Container name
+    \param appname Application name to look for
+    \param registry persistent connections to use
+*/
+bool Legacy::verifyAppname(const AppID::Package& package,
+                           const AppID::AppName& appname,
+                           const std::shared_ptr<Registry>& registry)
+{
+    if (!verifyPackage(package, registry))
+    {
+        throw std::runtime_error{"Invalid Legacy package: " + std::string(package)};
+    }
+
+    auto desktop = std::string(appname) + ".desktop";
+    auto evaldir = [&desktop](const gchar* dir) {
+        char* fulldir = g_build_filename(dir, "applications", desktop.c_str(), nullptr);
+        gboolean found = g_file_test(fulldir, G_FILE_TEST_EXISTS);
+        g_free(fulldir);
+        return found == TRUE;
+    };
+
+    if (evaldir(g_get_user_data_dir()))
+    {
+        return true;
+    }
+
+    auto&& data_dirs = g_get_system_data_dirs();
+    for (int i = 0; data_dirs[i] != nullptr; i++)
+    {
+        if (evaldir(data_dirs[i]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/** We don't really have a way to implement this for Legacy, any
+    search wouldn't really make sense. We just throw an error.
+
+    \param package Container name
+    \param card Application search paths
+    \param registry persistent connections to use
+*/
+AppID::AppName Legacy::findAppname(const AppID::Package& package,
+                                   AppID::ApplicationWildcard card,
+                                   const std::shared_ptr<Registry>& registry)
+{
+    throw std::runtime_error("Legacy apps can't be discovered by package");
+}
+
+/** Function to return an empty string
+
+    \param package Container name (unused)
+    \param appname Application name (unused)
+    \param registry persistent connections to use (unused)
+*/
+AppID::Version Legacy::findVersion(const AppID::Package& package,
+                                   const AppID::AppName& appname,
+                                   const std::shared_ptr<Registry>& registry)
+{
+    return AppID::Version::from_raw({});
+}
+
+static const std::regex desktop_remover("^(.*)\\.desktop$");
+
+std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry)
+{
+    std::list<std::shared_ptr<Application>> list;
+    GList* head = g_app_info_get_all();
+    for (GList* item = head; item != nullptr; item = g_list_next(item))
+    {
+        GDesktopAppInfo* appinfo = G_DESKTOP_APP_INFO(item->data);
+
+        if (appinfo == nullptr)
+        {
+            continue;
+        }
+
+        if (g_app_info_should_show(G_APP_INFO(appinfo)) == FALSE)
+        {
+            continue;
+        }
+
+        auto desktopappid = std::string(g_app_info_get_id(G_APP_INFO(appinfo)));
+        std::string appname;
+        std::smatch match;
+        if (std::regex_match(desktopappid, match, desktop_remover))
+        {
+            appname = match[1].str();
+        }
+        else
+        {
+            continue;
+        }
+
+        /* Remove entries generated by the desktop hook in .local */
+        if (g_desktop_app_info_has_key(appinfo, "X-Ubuntu-Application-ID"))
+        {
+            continue;
+        }
+
+        try
+        {
+            auto app = std::make_shared<app_impls::Legacy>(AppID::AppName::from_raw(appname), registry);
+            list.push_back(app);
+        }
+        catch (std::runtime_error& e)
+        {
+            g_debug("Unable to create application for legacy appname '%s': %s", appname.c_str(), e.what());
+        }
+    }
+
+    g_list_free_full(head, g_object_unref);
+
+    return list;
+}
+
+std::shared_ptr<app_impls::Base> Legacy::create(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    return std::make_shared<app_impls::Legacy>(appid.appname, registry);
+}
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-legacy.h'
--- libubuntu-app-launch/app-store-legacy.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-legacy.h	2017-03-18 19:37:40 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "app-store-base.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+class Legacy : public Base
+{
+public:
+    Legacy();
+    virtual ~Legacy();
+
+    /* Discover tools */
+    virtual bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) override;
+    virtual bool verifyAppname(const AppID::Package& package,
+                               const AppID::AppName& appname,
+                               const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::AppName findAppname(const AppID::Package& package,
+                                       AppID::ApplicationWildcard card,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::Version findVersion(const AppID::Package& package,
+                                       const AppID::AppName& appname,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual bool hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) override;
+
+    /* Possible apps */
+    virtual std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry) override;
+
+    /* Application Creation */
+    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid,
+                                                    const std::shared_ptr<Registry>& registry) override;
+};
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-libertine.cpp'
--- libubuntu-app-launch/app-store-libertine.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-libertine.cpp	2017-03-18 19:37:40 +0000
@@ -0,0 +1,173 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include "app-store-libertine.h"
+#include "application-impl-libertine.h"
+
+#include "libertine.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+Libertine::Libertine()
+{
+}
+
+Libertine::~Libertine()
+{
+}
+
+/** Checks the AppID by making sure the version is "0.0" and then
+    calling verifyAppname() to check the rest.
+
+    \param appid AppID to check
+    \param registry persistent connections to use
+*/
+bool Libertine::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        if (appid.version.value() != "0.0")
+        {
+            return false;
+        }
+
+        return verifyAppname(appid.package, appid.appname, registry);
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+/** Verify a package name by getting the list of containers from
+    liblibertine and ensuring it is in that list.
+
+    \param package Container name
+    \param registry persistent connections to use
+*/
+bool Libertine::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
+
+    for (int i = 0; containers.get()[i] != nullptr; i++)
+    {
+        auto container = containers.get()[i];
+        if (container == package.value())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/** Gets the list of applications from the container using liblibertine
+    and see if @appname is in that list.
+
+    \param package Container name
+    \param appname Application name to look for
+    \param registry persistent connections to use
+*/
+bool Libertine::verifyAppname(const AppID::Package& package,
+                              const AppID::AppName& appname,
+                              const std::shared_ptr<Registry>& registry)
+{
+    auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(package.value().c_str()), g_strfreev);
+
+    for (int i = 0; apps.get()[i] != nullptr; i++)
+    {
+        auto appid = AppID::parse(apps.get()[i]);
+        if (appid.appname.value() == appname.value())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/** We don't really have a way to implement this for Libertine, any
+    search wouldn't really make sense. We just throw an error.
+
+    \param package Container name
+    \param card Application search paths
+    \param registry persistent connections to use
+*/
+AppID::AppName Libertine::findAppname(const AppID::Package& package,
+                                      AppID::ApplicationWildcard card,
+                                      const std::shared_ptr<Registry>& registry)
+{
+    throw std::runtime_error("Legacy apps can't be discovered by package");
+}
+
+/** Function to return "0.0"
+
+    \param package Container name (unused)
+    \param appname Application name (unused)
+    \param registry persistent connections to use (unused)
+*/
+AppID::Version Libertine::findVersion(const AppID::Package& package,
+                                      const AppID::AppName& appname,
+                                      const std::shared_ptr<Registry>& registry)
+{
+    return AppID::Version::from_raw("0.0");
+}
+
+std::list<std::shared_ptr<Application>> Libertine::list(const std::shared_ptr<Registry>& registry)
+{
+    std::list<std::shared_ptr<Application>> applist;
+
+    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
+
+    for (int i = 0; containers.get()[i] != nullptr; i++)
+    {
+        auto container = containers.get()[i];
+        auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(container), g_strfreev);
+
+        for (int j = 0; apps.get()[j] != nullptr; j++)
+        {
+            try
+            {
+                auto appid = AppID::parse(apps.get()[j]);
+                auto sapp = std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry);
+                applist.emplace_back(sapp);
+            }
+            catch (std::runtime_error& e)
+            {
+                g_debug("Unable to create application for libertine appname '%s': %s", apps.get()[j], e.what());
+            }
+        }
+    }
+
+    return applist;
+}
+
+std::shared_ptr<app_impls::Base> Libertine::create(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry);
+}
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-libertine.h'
--- libubuntu-app-launch/app-store-libertine.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-libertine.h	2017-03-18 19:37:40 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "app-store-base.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+class Libertine : public Base
+{
+public:
+    Libertine();
+    virtual ~Libertine();
+
+    /* Discover tools */
+    virtual bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) override;
+    virtual bool verifyAppname(const AppID::Package& package,
+                               const AppID::AppName& appname,
+                               const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::AppName findAppname(const AppID::Package& package,
+                                       AppID::ApplicationWildcard card,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::Version findVersion(const AppID::Package& package,
+                                       const AppID::AppName& appname,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual bool hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) override;
+
+    /* Possible apps */
+    virtual std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry) override;
+
+    /* Application Creation */
+    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid,
+                                                    const std::shared_ptr<Registry>& registry) override;
+};
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-snap.cpp'
--- libubuntu-app-launch/app-store-snap.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-snap.cpp	2017-03-18 19:37:40 +0000
@@ -0,0 +1,231 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#include "app-store-snap.h"
+#include "application-impl-snap.h"
+#include "registry-impl.h"
+
+#include <regex>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+/************************
+ ** Interface Lists
+ ************************/
+
+/** All the interfaces that we run XMir for by default */
+const std::set<std::string> X11_INTERFACES{"unity7", "x11"};
+/** The interface to indicate direct Mir support */
+const std::string MIR_INTERFACE{"mir"};
+/** The interface to indicate Ubuntu lifecycle support */
+const std::string LIFECYCLE_INTERFACE{"unity8"};
+/** Snappy has more restrictive appnames than everyone else */
+const std::regex appnameRegex{"^[a-zA-Z0-9](?:-?[a-zA-Z0-9])*$"};
+
+Snap::Snap()
+{
+}
+
+Snap::~Snap()
+{
+}
+
+/** Checks if an AppID could be a snap. Note it doesn't look for a desktop
+    file just the package, app and version. This is done to make the lookup
+    quickly, as this function can be used to select which backend to use
+    and we want to reject quickly.
+
+    \param appid Application ID of the snap
+    \param registry Registry to use for persistent connections
+*/
+bool Snap::hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry)
+{
+    if (appId.package.value().empty() || appId.version.value().empty())
+    {
+        return false;
+    }
+
+    if (!std::regex_match(appId.appname.value(), appnameRegex))
+    {
+        return false;
+    }
+
+    auto pkginfo = registry->impl->snapdInfo.pkgInfo(appId.package);
+    return app_impls::Snap::checkPkgInfo(pkginfo, appId);
+}
+
+/** Look to see if a package is a valid Snap package name
+
+    \param package Package name
+    \param registry Registry to use for persistent connections
+*/
+bool Snap::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+        return pkgInfo != nullptr;
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+/** Look to see if an appname is a valid for a Snap package
+
+    \param package Package name
+    \param appname Command name
+    \param registry Registry to use for persistent connections
+*/
+bool Snap::verifyAppname(const AppID::Package& package,
+                         const AppID::AppName& appname,
+                         const std::shared_ptr<Registry>& registry)
+{
+    if (!std::regex_match(appname.value(), appnameRegex))
+    {
+        return false;
+    }
+
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+    return pkgInfo->appnames.find(appname) != pkgInfo->appnames.end();
+}
+
+/** Look for an application name on a Snap package based on a
+    wildcard type.
+
+    \param package Package name
+    \param card Wildcard to use for finding the appname
+    \param registry Registry to use for persistent connections
+*/
+AppID::AppName Snap::findAppname(const AppID::Package& package,
+                                 AppID::ApplicationWildcard card,
+                                 const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+
+    if (pkgInfo->appnames.empty())
+    {
+        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
+    }
+
+    switch (card)
+    {
+        case AppID::ApplicationWildcard::FIRST_LISTED:
+            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
+        case AppID::ApplicationWildcard::LAST_LISTED:
+            return AppID::AppName::from_raw(*pkgInfo->appnames.rbegin());
+        case AppID::ApplicationWildcard::ONLY_LISTED:
+            if (pkgInfo->appnames.size() != 1)
+            {
+                throw std::runtime_error("More than a single app in package '" + package.value() +
+                                         "' when requested to find only app");
+            }
+            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
+    }
+
+    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
+}
+
+/** Look for a version of a Snap package
+
+    \param package Package name
+    \param appname Not used for snaps
+    \param registry Registry to use for persistent connections
+*/
+AppID::Version Snap::findVersion(const AppID::Package& package,
+                                 const AppID::AppName& appname,
+                                 const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+    return AppID::Version::from_raw(pkgInfo->revision);
+}
+
+/** Operator to compare apps for our sets */
+struct appcompare
+{
+    bool operator()(const std::shared_ptr<Application>& a, const std::shared_ptr<Application>& b) const
+    {
+        return a->appId() < b->appId();
+    }
+};
+
+/** Lists all the Snappy apps that are using one of our supported interfaces.
+    Also makes sure they're valid.
+
+    \param registry Registry to use for persistent connections
+*/
+std::list<std::shared_ptr<Application>> Snap::list(const std::shared_ptr<Registry>& registry)
+{
+    std::set<std::shared_ptr<Application>, appcompare> apps;
+
+    auto lifecycleApps = registry->impl->snapdInfo.appsForInterface(LIFECYCLE_INTERFACE);
+
+    auto lifecycleForApp = [&](const AppID& appID) {
+        auto iterator = lifecycleApps.find(appID);
+        if (iterator == lifecycleApps.end())
+        {
+            return Application::Info::UbuntuLifecycle::from_raw(false);
+        }
+        else
+        {
+            return Application::Info::UbuntuLifecycle::from_raw(true);
+        }
+    };
+
+    auto addAppsForInterface = [&](const std::string& interface, app_info::Desktop::XMirEnable xMirEnable) {
+        for (const auto& id : registry->impl->snapdInfo.appsForInterface(interface))
+        {
+            auto interfaceInfo = std::make_tuple(xMirEnable, lifecycleForApp(id));
+            try
+            {
+                auto app = std::make_shared<app_impls::Snap>(id, registry, interfaceInfo);
+                apps.emplace(app);
+            }
+            catch (std::runtime_error& e)
+            {
+                g_debug("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
+            }
+        }
+    };
+
+    addAppsForInterface(MIR_INTERFACE, app_info::Desktop::XMirEnable::from_raw(false));
+
+    /* If an app has both, this will get rejected */
+    for (const auto& interface : X11_INTERFACES)
+    {
+        addAppsForInterface(interface, app_info::Desktop::XMirEnable::from_raw(true));
+    }
+
+    return std::list<std::shared_ptr<Application>>(apps.begin(), apps.end());
+}
+
+std::shared_ptr<app_impls::Base> Snap::create(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    return std::make_shared<app_impls::Snap>(appid, registry);
+}
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/app-store-snap.h'
--- libubuntu-app-launch/app-store-snap.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/app-store-snap.h	2017-03-18 19:37:40 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2017 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/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include "app-store-base.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_store
+{
+
+class Snap : public Base
+{
+public:
+    Snap();
+    virtual ~Snap();
+
+    /* Discover tools */
+    virtual bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) override;
+    virtual bool verifyAppname(const AppID::Package& package,
+                               const AppID::AppName& appname,
+                               const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::AppName findAppname(const AppID::Package& package,
+                                       AppID::ApplicationWildcard card,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual AppID::Version findVersion(const AppID::Package& package,
+                                       const AppID::AppName& appname,
+                                       const std::shared_ptr<Registry>& registry) override;
+    virtual bool hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) override;
+
+    /* Possible apps */
+    virtual std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry) override;
+
+    /* Application Creation */
+    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid,
+                                                    const std::shared_ptr<Registry>& registry) override;
+};
+
+}  // namespace app_store
+}  // namespace app_launch
+}  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-base.cpp'
--- libubuntu-app-launch/application-impl-base.cpp	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2017-03-18 19:37:40 +0000
@@ -24,10 +24,6 @@
 #include <numeric>
 
 #include "application-impl-base.h"
-#include "application-impl-click.h"
-#include "application-impl-legacy.h"
-#include "application-impl-libertine.h"
-#include "application-impl-snap.h"
 #include "helpers.h"
 #include "registry-impl.h"
 #include "second-exec-core.h"
@@ -54,39 +50,6 @@
     g_debug("Application deconstruction: %p", static_cast<void*>(this));
 }
 
-/* Put all the logic into a function so that we can deal have a simple
-   function to deal with each subtype */
-template <typename T>
-void watcher_append_list(const std::shared_ptr<Registry>& reg, std::list<std::shared_ptr<info_watcher::Base>>& list)
-{
-    auto watcher = T::createInfoWatcher(reg);
-
-    if (watcher)
-    {
-        list.push_back(watcher);
-    }
-}
-
-/* This little template makes it so that we can take a list, but
-   then break it down to calls to the base function. */
-template <typename T, typename T2, typename... TArgs>
-void watcher_append_list(const std::shared_ptr<Registry>& reg, std::list<std::shared_ptr<info_watcher::Base>>& list)
-{
-    watcher_append_list<T>(reg, list);
-    watcher_append_list<T2, TArgs...>(reg, list);
-}
-
-/** Builds an info watcher from each subclass and returns the list of
-    them to the registry */
-std::list<std::shared_ptr<info_watcher::Base>> Base::createInfoWatchers(const std::shared_ptr<Registry>& reg)
-{
-    std::list<std::shared_ptr<info_watcher::Base>> retval;
-
-    watcher_append_list<app_impls::Click, app_impls::Legacy, app_impls::Libertine, app_impls::Snap>(reg, retval);
-
-    return retval;
-}
-
 bool Base::hasInstances()
 {
     return !instances().empty();

=== modified file 'libubuntu-app-launch/application-impl-base.h'
--- libubuntu-app-launch/application-impl-base.h	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-base.h	2017-03-18 19:37:40 +0000
@@ -50,8 +50,6 @@
     virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) = 0;
     std::shared_ptr<Application::Instance> findInstance(const pid_t& pid);
 
-    static std::list<std::shared_ptr<info_watcher::Base>> createInfoWatchers(const std::shared_ptr<Registry>& reg);
-
 protected:
     /** Pointer to the registry so we can ask it for things */
     std::shared_ptr<Registry> _registry;

=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2017-03-18 19:37:40 +0000
@@ -30,8 +30,6 @@
 namespace app_impls
 {
 
-AppID::Version manifestVersion(const std::shared_ptr<JsonObject>& manifest);
-std::list<AppID::AppName> manifestApps(const std::shared_ptr<JsonObject>& manifest);
 std::pair<std::shared_ptr<GKeyFile>, std::string> manifestAppDesktop(const std::shared_ptr<JsonObject>& manifest,
                                                                      const std::string& package,
                                                                      const std::string& app,
@@ -60,115 +58,6 @@
     return _appid;
 }
 
-/** Check to see if this AppID has a desktop file that is in our link
-    farm built by Click. Click puts a symoblic link there for every
-    valid AppID.
-
-    \param appid Application ID to check
-    \param registry Persistent connections to use
-*/
-bool Click::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
-{
-    std::string appiddesktop = std::string(appid) + ".desktop";
-    gchar* click_link = nullptr;
-    const gchar* link_farm_dir = g_getenv("UBUNTU_APP_LAUNCH_LINK_FARM");
-    if (G_LIKELY(link_farm_dir == nullptr))
-    {
-        click_link =
-            g_build_filename(g_get_user_cache_dir(), "ubuntu-app-launch", "desktop", appiddesktop.c_str(), NULL);
-    }
-    else
-    {
-        click_link = g_build_filename(link_farm_dir, appiddesktop.c_str(), NULL);
-    }
-
-    bool click = g_file_test(click_link, G_FILE_TEST_EXISTS);
-    g_free(click_link);
-
-    return click;
-}
-
-/** Tries to get the Click manifest for a package. If it can successfully
-    get the manifest returns true.
-
-    \param package Name of the package
-    \param registry Persistent connections to use
-*/
-bool Click::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
-{
-    return registry->impl->getClickManifest(package) != nullptr;
-}
-
-/** Verifies the applicaiton name by getting the list of applications
-    in the package manifest and seeing if the appname is in the list.
-
-    \param package Name of the package
-    \param appname Name of the application
-    \param registry Persistent connections to use
-*/
-bool Click::verifyAppname(const AppID::Package& package,
-                          const AppID::AppName& appname,
-                          const std::shared_ptr<Registry>& registry)
-{
-    auto manifest = registry->impl->getClickManifest(package);
-    auto apps = manifestApps(manifest);
-
-    return std::find_if(apps.begin(), apps.end(), [&appname](const AppID::AppName& listApp) -> bool {
-               return appname.value() == listApp.value();
-           }) != apps.end();
-}
-
-/** Finds an application name based on a wildcard search. Gets the list
-    from the manifest, and then returns a value from that list.
-
-    \param package Name of the package
-    \param card Wildcard to search as
-    \param registry Persistent connections to use
-*/
-AppID::AppName Click::findAppname(const AppID::Package& package,
-                                  AppID::ApplicationWildcard card,
-                                  const std::shared_ptr<Registry>& registry)
-{
-    auto manifest = registry->impl->getClickManifest(package);
-    auto apps = manifestApps(manifest);
-
-    if (apps.empty())
-    {
-        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
-    }
-
-    switch (card)
-    {
-        case AppID::ApplicationWildcard::FIRST_LISTED:
-            return *apps.begin();
-        case AppID::ApplicationWildcard::LAST_LISTED:
-            return *apps.rbegin();
-        case AppID::ApplicationWildcard::ONLY_LISTED:
-            if (apps.size() != 1)
-            {
-                throw std::runtime_error("More than a single app in package '" + package.value() +
-                                         "' when requested to find only app");
-            }
-            return *apps.begin();
-    }
-
-    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
-}
-
-/** Find the version of a package that that is requested
-
-    \param package Name of the package
-    \param appname Name of the application (not used)
-    \param registry Persistent connections to use
-*/
-AppID::Version Click::findVersion(const AppID::Package& package,
-                                  const AppID::AppName& appname,
-                                  const std::shared_ptr<Registry>& registry)
-{
-    auto manifest = registry->impl->getClickManifest(package);
-    return manifestVersion(manifest);
-}
-
 std::shared_ptr<Application::Info> Click::info()
 {
     if (!_info)
@@ -193,39 +82,6 @@
     return cppstr;
 }
 
-std::list<AppID::AppName> manifestApps(const std::shared_ptr<JsonObject>& manifest)
-{
-    JsonObject* hooks = nullptr;
-    if (!json_object_has_member(manifest.get(), "hooks") ||
-        (hooks = json_object_get_object_member(manifest.get(), "hooks")) == nullptr)
-    {
-        throw std::runtime_error("Manifest does not have a 'hooks' field: " + Registry::Impl::printJson(manifest));
-    }
-
-    auto gapps = json_object_get_members(hooks);
-    if (gapps == nullptr)
-    {
-        throw std::runtime_error("GLib JSON confusion, please talk to your library vendor");
-    }
-
-    std::list<AppID::AppName> apps;
-
-    for (GList* item = gapps; item != nullptr; item = g_list_next(item))
-    {
-        auto appname = (const gchar*)item->data;
-
-        auto hooklist = json_object_get_object_member(hooks, appname);
-
-        if (json_object_has_member(hooklist, "desktop") == TRUE)
-        {
-            apps.emplace_back(AppID::AppName::from_raw(appname));
-        }
-    }
-
-    g_list_free(gapps);
-    return apps;
-}
-
 std::pair<std::shared_ptr<GKeyFile>, std::string> manifestAppDesktop(const std::shared_ptr<JsonObject>& manifest,
                                                                      const std::string& package,
                                                                      const std::string& app,
@@ -240,8 +96,8 @@
     if (!json_object_has_member(manifest.get(), "hooks") ||
         (hooks = json_object_get_object_member(manifest.get(), "hooks")) == nullptr)
     {
-        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'hooks' field: " +
-                                 Registry::Impl::printJson(manifest));
+        throw std::runtime_error("Manifest for application '" + app +
+                                 "' does not have a 'hooks' field: " + Registry::Impl::printJson(manifest));
     }
 
     auto gapps = json_object_get_members(hooks);
@@ -258,14 +114,14 @@
     if (!json_object_has_member(hooks, app.c_str()) ||
         (hooklist = json_object_get_object_member(hooks, app.c_str())) == nullptr)
     {
-        throw std::runtime_error("Manifest for does not have an application '" + app + "': " +
-                                 Registry::Impl::printJson(manifest));
+        throw std::runtime_error("Manifest for does not have an application '" + app +
+                                 "': " + Registry::Impl::printJson(manifest));
     }
 
     auto desktoppath = json_object_get_string_member(hooklist, "desktop");
     if (desktoppath == nullptr)
-        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'desktop' hook: " +
-                                 Registry::Impl::printJson(manifest));
+        throw std::runtime_error("Manifest for application '" + app +
+                                 "' does not have a 'desktop' hook: " + Registry::Impl::printJson(manifest));
 
     auto path = std::shared_ptr<gchar>(g_build_filename(clickDir.c_str(), desktoppath, nullptr), g_free);
 
@@ -281,48 +137,6 @@
     return std::make_pair(keyfile, std::string(path.get()));
 }
 
-std::list<std::shared_ptr<Application>> Click::list(const std::shared_ptr<Registry>& registry)
-{
-    std::list<std::shared_ptr<Application>> applist;
-
-    try
-    {
-        for (auto pkg : registry->impl->getClickPackages())
-        {
-            try
-            {
-                auto manifest = registry->impl->getClickManifest(pkg);
-
-                for (auto appname : manifestApps(manifest))
-                {
-                    try
-                    {
-                        AppID appid{pkg, appname, manifestVersion(manifest)};
-                        auto app = std::make_shared<Click>(appid, manifest, registry);
-                        applist.emplace_back(app);
-                    }
-                    catch (std::runtime_error& e)
-                    {
-                        g_debug("Unable to create Click for application '%s' in package '%s': %s",
-                                appname.value().c_str(), pkg.value().c_str(), e.what());
-                    }
-                }
-            }
-            catch (std::runtime_error& e)
-            {
-                g_debug("Unable to get information to build Click app on package '%s': %s", pkg.value().c_str(),
-                        e.what());
-            }
-        }
-    }
-    catch (std::runtime_error& e)
-    {
-        g_debug("Unable to get packages from Click database: %s", e.what());
-    }
-
-    return applist;
-}
-
 std::vector<std::shared_ptr<Application::Instance>> Click::instances()
 {
     auto vbase = _registry->impl->jobs->instances(appId(), "application-click");
@@ -370,11 +184,6 @@
     return _registry->impl->jobs->existing(appId(), "application-click", instanceid, std::vector<Application::URL>{});
 }
 
-std::shared_ptr<info_watcher::Base> Click::createInfoWatcher(const std::shared_ptr<Registry>& reg)
-{
-    return {};
-}
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-click.h'
--- libubuntu-app-launch/application-impl-click.h	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-click.h	2017-03-18 19:37:40 +0000
@@ -52,8 +52,6 @@
     Click(const AppID& appid, const std::shared_ptr<Registry>& registry);
     Click(const AppID& appid, const std::shared_ptr<JsonObject>& manifest, const std::shared_ptr<Registry>& registry);
 
-    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
-
     AppID appId() override;
 
     std::shared_ptr<Info> info() override;
@@ -63,23 +61,8 @@
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
-    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
-
-    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
-    static bool verifyAppname(const AppID::Package& package,
-                              const AppID::AppName& appname,
-                              const std::shared_ptr<Registry>& registry);
-    static AppID::AppName findAppname(const AppID::Package& package,
-                                      AppID::ApplicationWildcard card,
-                                      const std::shared_ptr<Registry>& registry);
-    static AppID::Version findVersion(const AppID::Package& package,
-                                      const AppID::AppName& appname,
-                                      const std::shared_ptr<Registry>& registry);
-
     virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) override;
 
-    static std::shared_ptr<info_watcher::Base> createInfoWatcher(const std::shared_ptr<Registry>& reg);
-
 private:
     AppID _appid;
 

=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2017-03-07 15:02:05 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2017-03-18 19:37:40 +0000
@@ -131,161 +131,6 @@
     return appinfo_;
 }
 
-/** Checks the AppID by ensuring the version and package are empty
-    then looks for the application.
-
-    \param appid AppID to check
-    \param registry persistent connections to use
-*/
-bool Legacy::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
-{
-    try
-    {
-        if (!appid.version.value().empty())
-        {
-            return false;
-        }
-
-        return verifyAppname(appid.package, appid.appname, registry);
-    }
-    catch (std::runtime_error& e)
-    {
-        return false;
-    }
-}
-
-/** Ensure the package is empty
-
-    \param package Container name
-    \param registry persistent connections to use
-*/
-bool Legacy::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
-{
-    return package.value().empty();
-}
-
-/** Looks for an application by looking through the system and user
-    application directories to find the desktop file.
-
-    \param package Container name
-    \param appname Application name to look for
-    \param registry persistent connections to use
-*/
-bool Legacy::verifyAppname(const AppID::Package& package,
-                           const AppID::AppName& appname,
-                           const std::shared_ptr<Registry>& registry)
-{
-    if (!verifyPackage(package, registry))
-    {
-        throw std::runtime_error{"Invalid Legacy package: " + std::string(package)};
-    }
-
-    auto desktop = std::string(appname) + ".desktop";
-    auto evaldir = [&desktop](const gchar* dir) -> bool {
-        char* fulldir = g_build_filename(dir, "applications", desktop.c_str(), nullptr);
-        gboolean found = g_file_test(fulldir, G_FILE_TEST_EXISTS);
-        g_free(fulldir);
-        return found == TRUE;
-    };
-
-    if (evaldir(g_get_user_data_dir()))
-    {
-        return true;
-    }
-
-    const char* const* data_dirs = g_get_system_data_dirs();
-    for (int i = 0; data_dirs[i] != nullptr; i++)
-    {
-        if (evaldir(data_dirs[i]))
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/** We don't really have a way to implement this for Legacy, any
-    search wouldn't really make sense. We just throw an error.
-
-    \param package Container name
-    \param card Application search paths
-    \param registry persistent connections to use
-*/
-AppID::AppName Legacy::findAppname(const AppID::Package& package,
-                                   AppID::ApplicationWildcard card,
-                                   const std::shared_ptr<Registry>& registry)
-{
-    throw std::runtime_error("Legacy apps can't be discovered by package");
-}
-
-/** Function to return an empty string
-
-    \param package Container name (unused)
-    \param appname Application name (unused)
-    \param registry persistent connections to use (unused)
-*/
-AppID::Version Legacy::findVersion(const AppID::Package& package,
-                                   const AppID::AppName& appname,
-                                   const std::shared_ptr<Registry>& registry)
-{
-    return AppID::Version::from_raw({});
-}
-
-static const std::regex desktop_remover("^(.*)\\.desktop$");
-
-std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry)
-{
-    std::list<std::shared_ptr<Application>> list;
-    GList* head = g_app_info_get_all();
-    for (GList* item = head; item != nullptr; item = g_list_next(item))
-    {
-        GDesktopAppInfo* appinfo = G_DESKTOP_APP_INFO(item->data);
-
-        if (appinfo == nullptr)
-        {
-            continue;
-        }
-
-        if (g_app_info_should_show(G_APP_INFO(appinfo)) == FALSE)
-        {
-            continue;
-        }
-
-        auto desktopappid = std::string(g_app_info_get_id(G_APP_INFO(appinfo)));
-        std::string appname;
-        std::smatch match;
-        if (std::regex_match(desktopappid, match, desktop_remover))
-        {
-            appname = match[1].str();
-        }
-        else
-        {
-            continue;
-        }
-
-        /* Remove entries generated by the desktop hook in .local */
-        if (g_desktop_app_info_has_key(appinfo, "X-Ubuntu-Application-ID"))
-        {
-            continue;
-        }
-
-        try
-        {
-            auto app = std::make_shared<Legacy>(AppID::AppName::from_raw(appname), registry);
-            list.push_back(app);
-        }
-        catch (std::runtime_error& e)
-        {
-            g_debug("Unable to create application for legacy appname '%s': %s", appname.c_str(), e.what());
-        }
-    }
-
-    g_list_free_full(head, g_object_unref);
-
-    return list;
-}
-
 std::vector<std::shared_ptr<Application::Instance>> Legacy::instances()
 {
     auto vbase = _registry->impl->jobs->instances(appId(), "application-legacy");
@@ -400,11 +245,6 @@
     return _registry->impl->jobs->existing(appId(), "application-legacy", instanceid, std::vector<Application::URL>{});
 }
 
-std::shared_ptr<info_watcher::Base> Legacy::createInfoWatcher(const std::shared_ptr<Registry>& reg)
-{
-    return {};
-}
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-legacy.h'
--- libubuntu-app-launch/application-impl-legacy.h	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2017-03-18 19:37:40 +0000
@@ -57,30 +57,13 @@
 
     std::shared_ptr<Info> info() override;
 
-    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
-
     std::vector<std::shared_ptr<Instance>> instances() override;
 
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
-    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
-
-    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
-    static bool verifyAppname(const AppID::Package& package,
-                              const AppID::AppName& appname,
-                              const std::shared_ptr<Registry>& registry);
-    static AppID::AppName findAppname(const AppID::Package& package,
-                                      AppID::ApplicationWildcard card,
-                                      const std::shared_ptr<Registry>& registry);
-    static AppID::Version findVersion(const AppID::Package& package,
-                                      const AppID::AppName& appname,
-                                      const std::shared_ptr<Registry>& registry);
-
     virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) override;
 
-    static std::shared_ptr<info_watcher::Base> createInfoWatcher(const std::shared_ptr<Registry>& reg);
-
 private:
     AppID::AppName _appname;
     std::string _basedir;

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2017-03-18 19:37:40 +0000
@@ -143,132 +143,6 @@
     return {};
 }
 
-/** Checks the AppID by making sure the version is "0.0" and then
-    calling verifyAppname() to check the rest.
-
-    \param appid AppID to check
-    \param registry persistent connections to use
-*/
-bool Libertine::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
-{
-    try
-    {
-        if (appid.version.value() != "0.0")
-        {
-            return false;
-        }
-
-        return verifyAppname(appid.package, appid.appname, registry);
-    }
-    catch (std::runtime_error& e)
-    {
-        return false;
-    }
-}
-
-/** Verify a package name by getting the list of containers from
-    liblibertine and ensuring it is in that list.
-
-    \param package Container name
-    \param registry persistent connections to use
-*/
-bool Libertine::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
-{
-    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
-
-    for (int i = 0; containers.get()[i] != nullptr; i++)
-    {
-        auto container = containers.get()[i];
-        if (container == package.value())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/** Gets the list of applications from the container using liblibertine
-    and see if @appname is in that list.
-
-    \param package Container name
-    \param appname Application name to look for
-    \param registry persistent connections to use
-*/
-bool Libertine::verifyAppname(const AppID::Package& package,
-                              const AppID::AppName& appname,
-                              const std::shared_ptr<Registry>& registry)
-{
-    auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(package.value().c_str()), g_strfreev);
-
-    for (int i = 0; apps.get()[i] != nullptr; i++)
-    {
-        auto appid = AppID::parse(apps.get()[i]);
-        if (appid.appname.value() == appname.value())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/** We don't really have a way to implement this for Libertine, any
-    search wouldn't really make sense. We just throw an error.
-
-    \param package Container name
-    \param card Application search paths
-    \param registry persistent connections to use
-*/
-AppID::AppName Libertine::findAppname(const AppID::Package& package,
-                                      AppID::ApplicationWildcard card,
-                                      const std::shared_ptr<Registry>& registry)
-{
-    throw std::runtime_error("Legacy apps can't be discovered by package");
-}
-
-/** Function to return "0.0"
-
-    \param package Container name (unused)
-    \param appname Application name (unused)
-    \param registry persistent connections to use (unused)
-*/
-AppID::Version Libertine::findVersion(const AppID::Package& package,
-                                      const AppID::AppName& appname,
-                                      const std::shared_ptr<Registry>& registry)
-{
-    return AppID::Version::from_raw("0.0");
-}
-
-std::list<std::shared_ptr<Application>> Libertine::list(const std::shared_ptr<Registry>& registry)
-{
-    std::list<std::shared_ptr<Application>> applist;
-
-    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
-
-    for (int i = 0; containers.get()[i] != nullptr; i++)
-    {
-        auto container = containers.get()[i];
-        auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(container), g_strfreev);
-
-        for (int j = 0; apps.get()[j] != nullptr; j++)
-        {
-            try
-            {
-                auto appid = AppID::parse(apps.get()[j]);
-                auto sapp = std::make_shared<Libertine>(appid.package, appid.appname, registry);
-                applist.emplace_back(sapp);
-            }
-            catch (std::runtime_error& e)
-            {
-                g_debug("Unable to create application for libertine appname '%s': %s", apps.get()[j], e.what());
-            }
-        }
-    }
-
-    return applist;
-}
-
 std::shared_ptr<Application::Info> Libertine::info()
 {
     return appinfo_;
@@ -337,11 +211,6 @@
     return _registry->impl->jobs->existing(appId(), "application-legacy", instanceid, std::vector<Application::URL>{});
 }
 
-std::shared_ptr<info_watcher::Base> Libertine::createInfoWatcher(const std::shared_ptr<Registry>& reg)
-{
-    return {};
-}
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-libertine.h'
--- libubuntu-app-launch/application-impl-libertine.h	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/application-impl-libertine.h	2017-03-18 19:37:40 +0000
@@ -54,8 +54,6 @@
               const AppID::AppName& appname,
               const std::shared_ptr<Registry>& registry);
 
-    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
-
     AppID appId() override
     {
         return {_container, _appname, AppID::Version::from_raw("0.0")};
@@ -68,23 +66,8 @@
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
-    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
-
-    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
-    static bool verifyAppname(const AppID::Package& package,
-                              const AppID::AppName& appname,
-                              const std::shared_ptr<Registry>& registry);
-    static AppID::AppName findAppname(const AppID::Package& package,
-                                      AppID::ApplicationWildcard card,
-                                      const std::shared_ptr<Registry>& registry);
-    static AppID::Version findVersion(const AppID::Package& package,
-                                      const AppID::AppName& appname,
-                                      const std::shared_ptr<Registry>& registry);
-
     virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) override;
 
-    static std::shared_ptr<info_watcher::Base> createInfoWatcher(const std::shared_ptr<Registry>& reg);
-
 private:
     AppID::Package _container;
     AppID::AppName _appname;

=== modified file 'libubuntu-app-launch/application-impl-snap.cpp'
--- libubuntu-app-launch/application-impl-snap.cpp	2017-03-09 15:40:03 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2017-03-18 19:37:40 +0000
@@ -58,7 +58,7 @@
 public:
     SnapInfo(const AppID& appid,
              const std::shared_ptr<Registry>& registry,
-             const Snap::InterfaceInfo &interfaceInfo,
+             const Snap::InterfaceInfo& interfaceInfo,
              const std::string& snapDir)
         : Desktop(appid,
                   [appid, snapDir]() -> std::shared_ptr<GKeyFile> {
@@ -181,7 +181,7 @@
     \param registry Registry to use for persistent connections
     \param interfaceInfo Metadata gleaned from the snap's interfaces
 */
-Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const InterfaceInfo &interfaceInfo)
+Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const InterfaceInfo& interfaceInfo)
     : Base(registry)
     , appid_(appid)
 {
@@ -212,65 +212,6 @@
 {
 }
 
-/** Operator to compare apps for our sets */
-struct appcompare
-{
-    bool operator()(const std::shared_ptr<Application>& a, const std::shared_ptr<Application>& b) const
-    {
-        return a->appId() < b->appId();
-    }
-};
-
-/** Lists all the Snappy apps that are using one of our supported interfaces.
-    Also makes sure they're valid.
-
-    \param registry Registry to use for persistent connections
-*/
-std::list<std::shared_ptr<Application>> Snap::list(const std::shared_ptr<Registry>& registry)
-{
-    std::set<std::shared_ptr<Application>, appcompare> apps;
-
-    auto lifecycleApps = registry->impl->snapdInfo.appsForInterface(LIFECYCLE_INTERFACE);
-
-    auto lifecycleForApp = [&](const AppID &appID) {
-        auto iterator = lifecycleApps.find(appID);
-        if (iterator == lifecycleApps.end())
-        {
-            return Application::Info::UbuntuLifecycle::from_raw(false);
-        }
-        else
-        {
-            return Application::Info::UbuntuLifecycle::from_raw(true);
-        }
-    };
-
-    auto addAppsForInterface = [&](const std::string& interface, app_info::Desktop::XMirEnable xMirEnable) {
-        for (const auto& id : registry->impl->snapdInfo.appsForInterface(interface))
-        {
-            auto interfaceInfo = std::make_tuple(xMirEnable, lifecycleForApp(id));
-            try
-            {
-                auto app = std::make_shared<Snap>(id, registry, interfaceInfo);
-                apps.emplace(app);
-            }
-            catch (std::runtime_error& e)
-            {
-                g_debug("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
-            }
-        }
-    };
-
-    addAppsForInterface(MIR_INTERFACE, app_info::Desktop::XMirEnable::from_raw(false));
-
-    /* If an app has both, this will get rejected */
-    for (const auto& interface : X11_INTERFACES)
-    {
-        addAppsForInterface(interface, app_info::Desktop::XMirEnable::from_raw(true));
-    }
-
-    return std::list<std::shared_ptr<Application>>(apps.begin(), apps.end());
-}
-
 /** Returns the stored AppID */
 AppID Snap::appId()
 {
@@ -326,117 +267,6 @@
            pkginfo->appnames.find(appid.appname) != pkginfo->appnames.end();
 }
 
-/** Checks if an AppID could be a snap. Note it doesn't look for a desktop
-    file just the package, app and version. This is done to make the lookup
-    quickly, as this function can be used to select which backend to use
-    and we want to reject quickly.
-
-    \param appid Application ID of the snap
-    \param registry Registry to use for persistent connections
-*/
-bool Snap::hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry)
-{
-    if (appId.package.value().empty() || appId.version.value().empty())
-    {
-        return false;
-    }
-
-    if (!std::regex_match(appId.appname.value(), appnameRegex))
-    {
-        return false;
-    }
-
-    auto pkginfo = registry->impl->snapdInfo.pkgInfo(appId.package);
-    return checkPkgInfo(pkginfo, appId);
-}
-
-/** Look to see if a package is a valid Snap package name
-
-    \param package Package name
-    \param registry Registry to use for persistent connections
-*/
-bool Snap::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
-{
-    try
-    {
-        auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
-        return pkgInfo != nullptr;
-    }
-    catch (std::runtime_error& e)
-    {
-        return false;
-    }
-}
-
-/** Look to see if an appname is a valid for a Snap package
-
-    \param package Package name
-    \param appname Command name
-    \param registry Registry to use for persistent connections
-*/
-bool Snap::verifyAppname(const AppID::Package& package,
-                         const AppID::AppName& appname,
-                         const std::shared_ptr<Registry>& registry)
-{
-    if (!std::regex_match(appname.value(), appnameRegex))
-    {
-        return false;
-    }
-
-    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
-    return pkgInfo->appnames.find(appname) != pkgInfo->appnames.end();
-}
-
-/** Look for an application name on a Snap package based on a
-    wildcard type.
-
-    \param package Package name
-    \param card Wildcard to use for finding the appname
-    \param registry Registry to use for persistent connections
-*/
-AppID::AppName Snap::findAppname(const AppID::Package& package,
-                                 AppID::ApplicationWildcard card,
-                                 const std::shared_ptr<Registry>& registry)
-{
-    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
-
-    if (pkgInfo->appnames.empty())
-    {
-        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
-    }
-
-    switch (card)
-    {
-        case AppID::ApplicationWildcard::FIRST_LISTED:
-            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
-        case AppID::ApplicationWildcard::LAST_LISTED:
-            return AppID::AppName::from_raw(*pkgInfo->appnames.rbegin());
-        case AppID::ApplicationWildcard::ONLY_LISTED:
-            if (pkgInfo->appnames.size() != 1)
-            {
-                throw std::runtime_error("More than a single app in package '" + package.value() +
-                                         "' when requested to find only app");
-            }
-            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
-    }
-
-    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
-}
-
-/** Look for a version of a Snap package
-
-    \param package Package name
-    \param appname Not used for snaps
-    \param registry Registry to use for persistent connections
-*/
-AppID::Version Snap::findVersion(const AppID::Package& package,
-                                 const AppID::AppName& appname,
-                                 const std::shared_ptr<Registry>& registry)
-{
-    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
-    return AppID::Version::from_raw(pkgInfo->revision);
-}
-
 /** Returns a reference to the info for the snap */
 std::shared_ptr<Application::Info> Snap::info()
 {
@@ -512,11 +342,6 @@
     return _registry->impl->jobs->existing(appId(), "application-snap", instanceid, std::vector<Application::URL>{});
 }
 
-std::shared_ptr<info_watcher::Base> Snap::createInfoWatcher(const std::shared_ptr<Registry>& reg)
-{
-    return {};
-}
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-snap.h'
--- libubuntu-app-launch/application-impl-snap.h	2017-03-09 15:40:03 +0000
+++ libubuntu-app-launch/application-impl-snap.h	2017-03-18 19:37:40 +0000
@@ -51,7 +51,7 @@
     typedef std::tuple<app_info::Desktop::XMirEnable, Application::Info::UbuntuLifecycle> InterfaceInfo;
 
     Snap(const AppID& appid, const std::shared_ptr<Registry>& registry);
-    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const InterfaceInfo &interfaceInfo);
+    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const InterfaceInfo& interfaceInfo);
 
     static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
 
@@ -64,22 +64,10 @@
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
-    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
-
-    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
-    static bool verifyAppname(const AppID::Package& package,
-                              const AppID::AppName& appname,
-                              const std::shared_ptr<Registry>& registry);
-    static AppID::AppName findAppname(const AppID::Package& package,
-                                      AppID::ApplicationWildcard card,
-                                      const std::shared_ptr<Registry>& registry);
-    static AppID::Version findVersion(const AppID::Package& package,
-                                      const AppID::AppName& appname,
-                                      const std::shared_ptr<Registry>& registry);
-
     virtual std::shared_ptr<Application::Instance> findInstance(const std::string& instanceid) override;
 
-    static std::shared_ptr<info_watcher::Base> createInfoWatcher(const std::shared_ptr<Registry>& reg);
+    static InterfaceInfo findInterfaceInfo(const AppID& appid, const std::shared_ptr<Registry>& registry);
+    static bool checkPkgInfo(const std::shared_ptr<snapd::Info::PkgInfo>& pkginfo, const AppID& appid);
 
 private:
     /** AppID of the Snap. Should be the name of the snap package.
@@ -92,8 +80,6 @@
     std::shared_ptr<snapd::Info::PkgInfo> pkgInfo_;
 
     std::list<std::pair<std::string, std::string>> launchEnv();
-    static InterfaceInfo findInterfaceInfo(const AppID& appid, const std::shared_ptr<Registry>& registry);
-    static bool checkPkgInfo(const std::shared_ptr<snapd::Info::PkgInfo>& pkginfo, const AppID& appid);
 };
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application.cpp'
--- libubuntu-app-launch/application.cpp	2017-02-09 03:23:40 +0000
+++ libubuntu-app-launch/application.cpp	2017-03-18 19:37:40 +0000
@@ -21,12 +21,6 @@
 #include "ubuntu-app-launch.h"
 }
 
-#include "application-impl-click.h"
-#include "application-impl-legacy.h"
-#include "application-impl-libertine.h"
-#ifdef ENABLE_SNAPPY
-#include "application-impl-snap.h"
-#endif
 #include "application.h"
 #include "info-watcher.h"
 #include "jobs-base.h"
@@ -59,28 +53,15 @@
         registry->impl->jobs = jobs::manager::Base::determineFactory(registry);
     }
 
-    if (app_impls::Click::hasAppId(appid, registry))
-    {
-        return std::make_shared<app_impls::Click>(appid, registry);
-    }
-#ifdef ENABLE_SNAPPY
-    else if (app_impls::Snap::hasAppId(appid, registry))
-    {
-        return std::make_shared<app_impls::Snap>(appid, registry);
-    }
-#endif
-    else if (app_impls::Libertine::hasAppId(appid, registry))
-    {
-        return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry);
-    }
-    else if (app_impls::Legacy::hasAppId(appid, registry))
-    {
-        return std::make_shared<app_impls::Legacy>(appid.appname, registry);
-    }
-    else
-    {
-        throw std::runtime_error("Invalid app ID: " + std::string(appid));
-    }
+    for (const auto& appStore : registry->impl->appStores())
+    {
+        if (appStore->hasAppId(appid, registry))
+        {
+            return appStore->create(appid, registry);
+        }
+    }
+
+    throw std::runtime_error("Invalid app ID: " + std::string(appid));
 }
 
 AppID::AppID()
@@ -195,42 +176,6 @@
     return package.value().empty() && appname.value().empty() && version.value().empty();
 }
 
-/** Basically we're making our own VTable of static functions. Static
-    functions don't go in the normal VTables, so we can't use our class
-    inheritance here to help. So we're just packing these puppies into
-    a data structure and iterating over it. */
-struct DiscoverTools
-{
-    std::function<bool(const AppID::Package& package, const std::shared_ptr<Registry>& registry)> verifyPackage;
-    std::function<bool(
-        const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)>
-        verifyAppname;
-    std::function<AppID::AppName(
-        const AppID::Package& package, AppID::ApplicationWildcard card, const std::shared_ptr<Registry>& registry)>
-        findAppname;
-    std::function<AppID::Version(
-        const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)>
-        findVersion;
-    std::function<bool(const AppID& appid, const std::shared_ptr<Registry>& registry)> hasAppId;
-};
-
-/** The tools in order that they should be used */
-static const std::vector<DiscoverTools> discoverTools{
-    /* Click */
-    {app_impls::Click::verifyPackage, app_impls::Click::verifyAppname, app_impls::Click::findAppname,
-     app_impls::Click::findVersion, app_impls::Click::hasAppId},
-#ifdef ENABLE_SNAPPY
-    /* Snap */
-    {app_impls::Snap::verifyPackage, app_impls::Snap::verifyAppname, app_impls::Snap::findAppname,
-     app_impls::Snap::findVersion, app_impls::Snap::hasAppId},
-#endif
-    /* Libertine */
-    {app_impls::Libertine::verifyPackage, app_impls::Libertine::verifyAppname, app_impls::Libertine::findAppname,
-     app_impls::Libertine::findVersion, app_impls::Libertine::hasAppId},
-    /* Legacy */
-    {app_impls::Legacy::verifyPackage, app_impls::Legacy::verifyAppname, app_impls::Legacy::findAppname,
-     app_impls::Legacy::findVersion, app_impls::Legacy::hasAppId}};
-
 AppID AppID::discover(const std::shared_ptr<Registry>& registry,
                       const std::string& package,
                       const std::string& appname,
@@ -238,31 +183,31 @@
 {
     auto pkg = AppID::Package::from_raw(package);
 
-    for (const auto& tools : discoverTools)
+    for (const auto& appStore : registry->impl->appStores())
     {
         /* Figure out which type we have */
         try
         {
-            if (tools.verifyPackage(pkg, registry))
+            if (appStore->verifyPackage(pkg, registry))
             {
                 auto app = AppID::AppName::from_raw({});
 
                 if (appname.empty() || appname == "first-listed-app")
                 {
-                    app = tools.findAppname(pkg, ApplicationWildcard::FIRST_LISTED, registry);
+                    app = appStore->findAppname(pkg, ApplicationWildcard::FIRST_LISTED, registry);
                 }
                 else if (appname == "last-listed-app")
                 {
-                    app = tools.findAppname(pkg, ApplicationWildcard::LAST_LISTED, registry);
+                    app = appStore->findAppname(pkg, ApplicationWildcard::LAST_LISTED, registry);
                 }
                 else if (appname == "only-listed-app")
                 {
-                    app = tools.findAppname(pkg, ApplicationWildcard::ONLY_LISTED, registry);
+                    app = appStore->findAppname(pkg, ApplicationWildcard::ONLY_LISTED, registry);
                 }
                 else
                 {
                     app = AppID::AppName::from_raw(appname);
-                    if (!tools.verifyAppname(pkg, app, registry))
+                    if (!appStore->verifyAppname(pkg, app, registry))
                     {
                         throw std::runtime_error("App name passed in is not valid for this package type");
                     }
@@ -271,12 +216,12 @@
                 auto ver = AppID::Version::from_raw({});
                 if (version.empty() || version == "current-user-version")
                 {
-                    ver = tools.findVersion(pkg, app, registry);
+                    ver = appStore->findVersion(pkg, app, registry);
                 }
                 else
                 {
                     ver = AppID::Version::from_raw(version);
-                    if (!tools.hasAppId({pkg, app, ver}, registry))
+                    if (!appStore->hasAppId({pkg, app, ver}, registry))
                     {
                         throw std::runtime_error("Invalid version passed for this package type");
                     }
@@ -301,14 +246,14 @@
 {
     auto pkg = AppID::Package::from_raw(package);
 
-    for (const auto& tools : discoverTools)
+    for (const auto& appStore : registry->impl->appStores())
     {
         try
         {
-            if (tools.verifyPackage(pkg, registry))
+            if (appStore->verifyPackage(pkg, registry))
             {
-                auto app = tools.findAppname(pkg, appwildcard, registry);
-                auto ver = tools.findVersion(pkg, app, registry);
+                auto app = appStore->findAppname(pkg, appwildcard, registry);
+                auto ver = appStore->findVersion(pkg, app, registry);
                 return AppID{pkg, app, ver};
             }
         }
@@ -330,13 +275,13 @@
     auto pkg = AppID::Package::from_raw(package);
     auto app = AppID::AppName::from_raw(appname);
 
-    for (const auto& tools : discoverTools)
+    for (const auto& appStore : registry->impl->appStores())
     {
         try
         {
-            if (tools.verifyPackage(pkg, registry) && tools.verifyAppname(pkg, app, registry))
+            if (appStore->verifyPackage(pkg, registry) && appStore->verifyAppname(pkg, app, registry))
             {
-                auto ver = tools.findVersion(pkg, app, registry);
+                auto ver = appStore->findVersion(pkg, app, registry);
                 return AppID{pkg, app, ver};
             }
         }

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2017-02-10 16:50:40 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2017-03-18 19:37:40 +0000
@@ -43,6 +43,7 @@
              })
     , _registry{registry}
     , _iconFinders()
+    , _appStores(app_store::Base::allAppStores())
 {
     auto cancel = thread.getCancellable();
     _dbus = thread.executeOnThread<std::shared_ptr<GDBusConnection>>([cancel]() {
@@ -311,14 +312,15 @@
     std::call_once(flag_appInfoUpdated, [this, reg] {
         g_debug("App Info Updated Signal Initialized");
 
-        auto apps = app_impls::Base::createInfoWatchers(reg);
+        std::list<std::shared_ptr<info_watcher::Base>> apps{_appStores.begin(), _appStores.end()};
         apps.push_back(Registry::Impl::getZgWatcher(reg));
 
         for (const auto& app : apps)
         {
             infoWatchers_.emplace_back(
-                std::make_pair(app, app->infoChanged().connect(
-                                        [this](const std::shared_ptr<Application>& app) { sig_appInfoUpdated(app); })));
+                std::make_pair(app, app->infoChanged().connect([this](const std::shared_ptr<Application>& app) {
+                    sig_appInfoUpdated(app);
+                })));
         }
     });
     return sig_appInfoUpdated;

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2017-02-10 16:50:40 +0000
+++ libubuntu-app-launch/registry-impl.h	2017-03-18 19:37:40 +0000
@@ -17,6 +17,7 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "app-store-base.h"
 #include "glib-thread.h"
 #include "info-watcher-zg.h"
 #include "jobs-base.h"
@@ -99,6 +100,11 @@
 
     core::Signal<const std::shared_ptr<Application>&>& appInfoUpdated(const std::shared_ptr<Registry>& reg);
 
+    std::list<std::shared_ptr<app_store::Base>> appStores()
+    {
+        return _appStores;
+    }
+
 private:
     Registry* _registry; /**< The Registry that we're spawned from */
 
@@ -117,6 +123,9 @@
     /** Path to the OOM Helper */
     std::string oomHelper_;
 
+    /** Application stores */
+    std::list<std::shared_ptr<app_store::Base>> _appStores;
+
     /** Signal for application info changing */
     core::Signal<const std::shared_ptr<Application>&> sig_appInfoUpdated;
     /** Flag to see if we've initialized the info watcher list */

=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2017-02-15 15:09:51 +0000
+++ libubuntu-app-launch/registry.cpp	2017-03-18 19:37:40 +0000
@@ -24,13 +24,6 @@
 #include "registry-impl.h"
 #include "registry.h"
 
-#include "application-impl-click.h"
-#include "application-impl-legacy.h"
-#include "application-impl-libertine.h"
-#ifdef ENABLE_SNAPPY
-#include "application-impl-snap.h"
-#endif
-
 #include "helper-impl-click.h"
 
 namespace ubuntu
@@ -61,12 +54,10 @@
 {
     std::list<std::shared_ptr<Application>> list;
 
-    list.splice(list.begin(), app_impls::Click::list(connection));
-    list.splice(list.begin(), app_impls::Legacy::list(connection));
-    list.splice(list.begin(), app_impls::Libertine::list(connection));
-#ifdef ENABLE_SNAPPY
-    list.splice(list.begin(), app_impls::Snap::list(connection));
-#endif
+    for (const auto& appStore : connection->impl->appStores())
+    {
+        list.splice(list.begin(), appStore->list(connection));
+    }
 
     return list;
 }

=== modified file 'tests/list-apps.cpp'
--- tests/list-apps.cpp	2017-03-09 15:40:03 +0000
+++ tests/list-apps.cpp	2017-03-18 19:37:40 +0000
@@ -25,9 +25,10 @@
 #include "eventually-fixture.h"
 #include "libertine-service.h"
 
-#include "application-impl-click.h"
-#include "application-impl-legacy.h"
-#include "application-impl-libertine.h"
+#include "app-store-click.h"
+#include "app-store-legacy.h"
+#include "app-store-libertine.h"
+#include "app-store-snap.h"
 #include "application-impl-snap.h"
 #include "application.h"
 #include "registry.h"
@@ -155,7 +156,8 @@
 TEST_F(ListApps, ListClick)
 {
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
-    auto apps = ubuntu::app_launch::app_impls::Click::list(registry);
+    ubuntu::app_launch::app_store::Click store;
+    auto apps = store.list(registry);
 
     printApps(apps);
 
@@ -182,7 +184,8 @@
 TEST_F(ListApps, ListLegacy)
 {
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
-    auto apps = ubuntu::app_launch::app_impls::Legacy::list(registry);
+    ubuntu::app_launch::app_store::Legacy store;
+    auto apps = store.list(registry);
 
     printApps(apps);
 
@@ -196,7 +199,8 @@
 TEST_F(ListApps, ListLibertine)
 {
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
-    auto apps = ubuntu::app_launch::app_impls::Libertine::list(registry);
+    ubuntu::app_launch::app_store::Libertine store;
+    auto apps = store.list(registry);
 
     printApps(apps);
 
@@ -239,7 +243,8 @@
                     interfaces, x11Package, x11Package, x11Package}}; /* x11 check */
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
 
-    auto apps = ubuntu::app_launch::app_impls::Snap::list(registry);
+    ubuntu::app_launch::app_store::Snap store;
+    auto apps = store.list(registry);
 
     printApps(apps);