Ubuntu Application Launcher

Merge lp:~mterry/ubuntu-app-launch/look-at-mir into lp:ubuntu-app-launch

look-at-mir
Merge into trunk.17.04

Proposed by Michael Terry on 2017-02-16

Status:	Merged
Approved by:	Michael Terry on 2017-03-09
Approved revision:	291
Merged at revision:	299
Proposed branch:	lp:~mterry/ubuntu-app-launch/look-at-mir
Merge into:	lp:ubuntu-app-launch
Prerequisite:	lp:~ted/ubuntu-app-launch/zg-ordering
Diff against target:	438 lines (+124/-100) 5 files modified libubuntu-app-launch/application-impl-snap.cpp (+61/-69) libubuntu-app-launch/application-impl-snap.h (+5/-11) tests/applications/qmlapp.desktop (+8/-0) tests/libual-cpp-test.cc (+24/-1) tests/list-apps.cpp (+26/-19)
To merge this branch:	bzr merge lp:~mterry/ubuntu-app-launch/look-at-mir
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
unity-api-1-bot	continuous-integration	2017-02-16	Approve on 2017-03-09
Larry Price		2017-02-16	Approve on 2017-03-09
Review via email: mp+317520@code.launchpad.net

This proposal supersedes a proposal from 2017-02-14.

Commit Message

Use the "mir" interface (not the "unity8" interface) to decide if an app supports Mir or not.

Description of the Change

I know we were initially considering having the mir socket permissions in the unity8 interface. But they now live in the mir interface, so that's what we should pay attention to.

I left the "look at unity8 for lifecycle support" bits intact.

unity-api-1-bot (unity-api-1-bot) wrote on 2017-02-14: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Michael Terry (mterry) wrote on 2017-02-15: Posted in a previous version of this proposal

Hmm, I set this to WIP while I looked at the test failures. But I think they're all from the libertine moving target. I'll go back to Ready and just wait for that silo to land. Then see what CI says. This seems to be clear if I merge in the pending branches...

unity-api-1-bot (unity-api-1-bot) wrote on 2017-02-16:

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

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2017-02-27:

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

review: Needs Fixing (continuous-integration)

unity-api-1-bot (unity-api-1-bot) wrote on 2017-03-08:

PASSED: Continuous integration, rev:289
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/253/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1763
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1770
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1546/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1546/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1546/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1546/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1546/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1546
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1546/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

Larry Price (larryprice) wrote on 2017-03-09:

lgtm

review: Approve

lp:~mterry/ubuntu-app-launch/look-at-mir updated on 2017-03-09

290. By Michael Terry on 2017-03-09: Merge trunk
291. By Michael Terry on 2017-03-09: Add test for how trying to create non-graphical app Application object fails

unity-api-1-bot (unity-api-1-bot) wrote on 2017-03-09:

PASSED: Continuous integration, rev:291
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/254/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1768
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1775
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1551/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1551/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1551/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1551/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1551/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1551
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1551/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Indicator Applet Developers

Michael Terry

 === modified file 'libubuntu-app-launch/application-impl-snap.cpp'
 --- libubuntu-app-launch/application-impl-snap.cpp	2017-02-15 15:09:51 +0000
 +++ libubuntu-app-launch/application-impl-snap.cpp	2017-03-09 16:05:52 +0000
@@ -35,9 +35,11 @@
   ************************/
  /** All the interfaces that we run XMir for by default */
--const std::set<std::string> XMIR_INTERFACES{"unity7", "x11"};
--/** All the interfaces that we tell Unity support lifecycle */
--const std::set<std::string> LIFECYCLE_INTERFACES{"unity8"};
++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])*$"};
@@ -50,15 +52,13 @@
      fields to the desktop spec that come from Snappy interfaces. */
  class SnapInfo : public app_info::Desktop
+ {
--    /** The core interface for this snap */
--    std::string interface_;
      /** AppID of snap */
      AppID appId_;
  public:
      SnapInfo(const AppID& appid,
               const std::shared_ptr<Registry>& registry,
--             const std::string& interface,
++             const Snap::InterfaceInfo &interfaceInfo,
               const std::string& snapDir)
          : Desktop(appid,
                    [appid, snapDir]() -> std::shared_ptr<GKeyFile> {
@@ -112,37 +112,10 @@
                    snapDir,
                    app_info::DesktopFlags::NONE,
                    registry)
--        , interface_(interface)
          , appId_(appid)
+     {
--    }
--
--    /** Return the xMirEnable value based on whether the interface is
--        in the list of interfaces using XMir */
--    XMirEnable xMirEnable() override
--    {
--        if (XMIR_INTERFACES.find(interface_) != XMIR_INTERFACES.end())
--        {
--            return XMirEnable::from_raw(true);
--        }
--        else
--        {
--            return XMirEnable::from_raw(false);
--        }
--    }
--
--    /** Return the xMirEnable value based on whether the interface is
--        in the list of interfaces supporting the lifecycle */
--    UbuntuLifecycle supportsUbuntuLifecycle() override
--    {
--        if (LIFECYCLE_INTERFACES.find(interface_) != LIFECYCLE_INTERFACES.end())
--        {
--            return UbuntuLifecycle::from_raw(true);
--        }
--        else
--        {
--            return UbuntuLifecycle::from_raw(false);
--        }
++        _xMirEnable = std::get<0>(interfaceInfo);
++        _ubuntuLifecycle = std::get<1>(interfaceInfo);
+     }
      /** Figures out the exec line for a snappy command. We're not using
@@ -206,12 +179,11 @@
      \param appid Application ID of the snap
      \param registry Registry to use for persistent connections
--    \param interface Primary interface that we found this snap for
++    \param interfaceInfo Metadata gleaned from the snap's interfaces
  */
--Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const std::string& interface)
++Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const InterfaceInfo &interfaceInfo)
      : Base(registry)
      , appid_(appid)
--    , interface_(interface)
+ {
      pkgInfo_ = registry->impl->snapdInfo.pkgInfo(appid.package);
      if (!pkgInfo_)
@@ -224,19 +196,19 @@
          throw std::runtime_error("AppID does not match installed package for: " + std::string(appid));
+     }
--    info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
++    info_ = std::make_shared<SnapInfo>(appid_, _registry, interfaceInfo, pkgInfo_->directory);
      g_debug("Application Snap object for AppID '%s'", std::string(appid).c_str());
+ }
--/** Uses the findInterface() function to find the interface if we don't
++/** Uses the findInterfaceInfo() function to find the interface if we don't
      have one.
      \param appid Application ID of the snap
      \param registry Registry to use for persistent connections
  */
  Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry)
--    : Snap(appid, registry, findInterface(appid, registry))
++    : Snap(appid, registry, findInterfaceInfo(appid, registry))
+ {
+ }
@@ -258,12 +230,27 @@
+ {
      std::set<std::shared_ptr<Application>, appcompare> apps;
--    auto addAppsForInterface = [&](const std::string& interface) {
++    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, interface);
++                auto app = std::make_shared<Snap>(id, registry, interfaceInfo);
                  apps.emplace(app);
+             }
              catch (std::runtime_error& e)
@@ -273,15 +260,12 @@
+         }
      };
--    for (const auto& interface : LIFECYCLE_INTERFACES)
--    {
--        addAppsForInterface(interface);
--    }
++    addAppsForInterface(MIR_INTERFACE, app_info::Desktop::XMirEnable::from_raw(false));
      /* If an app has both, this will get rejected */
--    for (const auto& interface : XMIR_INTERFACES)
++    for (const auto& interface : X11_INTERFACES)
+     {
--        addAppsForInterface(interface);
++        addAppsForInterface(interface, app_info::Desktop::XMirEnable::from_raw(true));
+     }
      return std::list<std::shared_ptr<Application>>(apps.begin(), apps.end());
@@ -293,33 +277,41 @@
      return appid_;
+ }
--/** Asks Snapd for the interfaces to determine which one the application
++/** Asks Snapd for the interfaces to determine which ones the application
      can support.
      \param appid Application ID of the snap
      \param registry Registry to use for persistent connections
  */
--std::string Snap::findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry)
++Snap::InterfaceInfo Snap::findInterfaceInfo(const AppID& appid, const std::shared_ptr<Registry>& registry)
+ {
      auto ifaceset = registry->impl->snapdInfo.interfacesForAppId(appid);
--
--    for (const auto& interface : LIFECYCLE_INTERFACES)
--    {
--        if (ifaceset.find(interface) != ifaceset.end())
--        {
--            return interface;
--        }
--    }
--
--    for (const auto& interface : XMIR_INTERFACES)
--    {
--        if (ifaceset.find(interface) != ifaceset.end())
--        {
--            return interface;
--        }
--    }
--
--    throw std::runtime_error("Interface not found for: " + std::string(appid));
++    auto xMirEnable = app_info::Desktop::XMirEnable::from_raw(false);
++    auto ubuntuLifecycle = Application::Info::UbuntuLifecycle::from_raw(false);
++
++    if (ifaceset.find(LIFECYCLE_INTERFACE) != ifaceset.end())
++    {
++        ubuntuLifecycle = Application::Info::UbuntuLifecycle::from_raw(true);
++    }
++
++    if (ifaceset.find(MIR_INTERFACE) == ifaceset.end())
++    {
++        for (const auto& interface : X11_INTERFACES)
++        {
++            if (ifaceset.find(interface) != ifaceset.end())
++            {
++                xMirEnable = app_info::Desktop::XMirEnable::from_raw(true);
++                break;
++            }
++        }
++
++        if (!xMirEnable.value())
++        {
++            throw std::runtime_error("Graphical interface not found for: " + std::string(appid));
++        }
++    }
++
++    return std::make_tuple(xMirEnable, ubuntuLifecycle);
+ }
  /** Checks a PkgInfo structure to ensure that it matches the AppID */
 === modified file 'libubuntu-app-launch/application-impl-snap.h'
 --- libubuntu-app-launch/application-impl-snap.h	2017-02-15 15:09:51 +0000
 +++ libubuntu-app-launch/application-impl-snap.h	2017-03-09 16:05:52 +0000
@@ -34,7 +34,7 @@
      system as Snaps. This class connects to snapd to get information
      on the interfaces of the installed snaps and sees if any of them
      are applicable to the user session. Currently that means if the
--    command has the unity8, unity7 or x11 interface.
++    command has the mir, unity8, unity7 or x11 interfaces.
      For Application IDs snaps use a very similar scheme to Click
      packages. The package field is the name of the snap package, typically
@@ -48,8 +48,10 @@
  class Snap : public Base
+ {
  public:
++    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 std::string& interface);
++    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);
@@ -79,11 +81,6 @@
      static std::shared_ptr<info_watcher::Base> createInfoWatcher(const std::shared_ptr<Registry>& reg);
--    const std::string& getInterface() const
--    {
--        return interface_;
--    }
--
  private:
      /** AppID of the Snap. Should be the name of the snap package.
          The name of the command. And then the revision. */
@@ -91,14 +88,11 @@
      /** The app's displayed information. Should be from a desktop
          file that is put in ${SNAP_DIR}/meta/gui/${command}.desktop */
      std::shared_ptr<app_info::Desktop> info_;
--    /** Which interface we thing we're coming from. Depends on how
--        we handle setting up the environment for the command. */
--    std::string interface_;
      /** Information that we get from Snapd on the package */
      std::shared_ptr<snapd::Info::PkgInfo> pkgInfo_;
      std::list<std::pair<std::string, std::string>> launchEnv();
--    static std::string findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry);
++    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);
  };
 === added file 'tests/applications/qmlapp.desktop'
 --- tests/applications/qmlapp.desktop	1970-01-01 00:00:00 +0000
 +++ tests/applications/qmlapp.desktop	2017-03-09 16:05:52 +0000
@@ -0,0 +1,8 @@
++[Desktop Entry]
++Name=Qml App
++Type=Application
++Exec=qmlapp
++NoDisplay=false
++Hidden=false
++Terminal=false
++Icon=/snap/unity8-package/current/qmlapp.png
 === modified file 'tests/libual-cpp-test.cc'
 --- tests/libual-cpp-test.cc	2017-02-15 15:10:07 +0000
 +++ tests/libual-cpp-test.cc	2017-03-09 16:05:52 +0000
@@ -529,11 +529,15 @@
  static std::pair<std::string, std::string> interfaces{
      "GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
      SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
--        SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "single", "xmir", "noxmir"}}})))};
++        SnapdMock::interfacesJson({{"mir", "unity8-package", {"foo", "single", "xmir", "noxmir"}}})))};
  static std::pair<std::string, std::string> u8Package{
      "GET /v2/snaps/unity8-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
      SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
          "unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "single", "xmir", "noxmir"})))};
++static std::pair<std::string, std::string> helloPackage{
++    "GET /v2/snaps/hello HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
++    SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
++        "hello", "active", "app", "1.0", "1", {"hello"})))};
  TEST_F(LibUAL, ApplicationIdSnap)
+ {
@@ -595,6 +599,25 @@
      EXPECT_EQ(expected, app->info()->iconPath().value());
+ }
++TEST_F(LibUAL, NoGraphicalSnapInterface)
++{
++    SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET, {helloPackage, interfaces, helloPackage}};
++    registry = std::make_shared<ubuntu::app_launch::Registry>();
++
++    auto appid = ubuntu::app_launch::AppID::parse("hello_hello_1");
++
++    try {
++        ubuntu::app_launch::Application::create(appid, registry);
++        FAIL() << "Expected std::runtime_error";
++    }
++    catch(std::runtime_error const & err) {
++        EXPECT_EQ(err.what(), std::string("Graphical interface not found for: hello_hello_1"));
++    }
++    catch(...) {
++        FAIL() << "Expected std::runtime_error";
++    }
++}
++
  TEST_F(LibUAL, StartSnapApplication)
+ {
      SnapdMock snapd{LOCAL_SNAPD_TEST_SOCKET, {u8Package, interfaces, u8Package}};
 === modified file 'tests/list-apps.cpp'
 --- tests/list-apps.cpp	2017-02-14 15:57:05 +0000
 +++ tests/list-apps.cpp	2017-03-09 16:05:52 +0000
@@ -211,6 +211,7 @@
      "GET /v2/interfaces HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
      SnapdMock::httpJsonResponse(
          SnapdMock::snapdOkay(SnapdMock::interfacesJson({{"unity8", "unity8-package", {"foo", "bar"}},
++                                                        {"mir", "unity8-package", {"qmlapp"}},
                                                          {"unity7", "unity8-package", {"foo"}},
                                                          {"unity7", "unity7-package", {"single", "multiple"}},
                                                          {"x11", "x11-package", {"multiple", "hidden"}}
@@ -219,7 +220,7 @@
  static std::pair<std::string, std::string> u8Package{
      "GET /v2/snaps/unity8-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
      SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(
--        SnapdMock::packageJson("unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "bar"})))};
++        SnapdMock::packageJson("unity8-package", "active", "app", "1.2.3.4", "x123", {"foo", "bar", "qmlapp"})))};
  static std::pair<std::string, std::string> u7Package{
      "GET /v2/snaps/unity7-package HTTP/1.1\r\nHost: snapd\r\nAccept: */*\r\n\r\n",
      SnapdMock::httpJsonResponse(SnapdMock::snapdOkay(SnapdMock::packageJson(
@@ -232,9 +233,10 @@
  TEST_F(ListApps, ListSnap)
+ {
      SnapdMock mock{SNAPD_LIST_APPS_SOCKET,
--                   {interfaces, u8Package, u8Package, u8Package,                       /* unity8 check */
++                   {interfaces, u8Package, /* unity8 check */
++                    interfaces, u8Package, u8Package, /* mir check */
                      interfaces, u8Package, u7Package, u7Package, u7Package, u8Package, /* unity7 check */
--                    interfaces, x11Package, x11Package, x11Package}};                  /* x11 check */
++                    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);
@@ -243,8 +245,9 @@
      mock.result();
--    EXPECT_EQ(4, int(apps.size()));
++    EXPECT_EQ(5, int(apps.size()));
      EXPECT_TRUE(findApp(apps, "unity8-package_foo_x123"));
++    EXPECT_TRUE(findApp(apps, "unity8-package_qmlapp_x123"));
      EXPECT_TRUE(findApp(apps, "unity7-package_single_x123"));
      EXPECT_TRUE(findApp(apps, "unity7-package_multiple_x123"));
      EXPECT_TRUE(findApp(apps, "x11-package_multiple_x123"));
@@ -253,18 +256,21 @@
      EXPECT_FALSE(findApp(apps, "unity7-package_scope_x123"));
      EXPECT_FALSE(findApp(apps, "x11-package_hidden_x123"));
--    EXPECT_EQ("unity8",
--              std::dynamic_pointer_cast<ubuntu::app_launch::app_impls::Snap>(getApp(apps, "unity8-package_foo_x123"))
--                  ->getInterface());
--    EXPECT_EQ("unity7",
--              std::dynamic_pointer_cast<ubuntu::app_launch::app_impls::Snap>(getApp(apps, "unity7-package_single_x123"))
--                  ->getInterface());
--    EXPECT_EQ("unity7", std::dynamic_pointer_cast<ubuntu::app_launch::app_impls::Snap>(
--                            getApp(apps, "unity7-package_multiple_x123"))
--                            ->getInterface());
--    EXPECT_EQ("x11",
--              std::dynamic_pointer_cast<ubuntu::app_launch::app_impls::Snap>(getApp(apps, "x11-package_multiple_x123"))
--                  ->getInterface());
++    EXPECT_TRUE(getApp(apps, "unity8-package_foo_x123")->info()
++                    ->supportsUbuntuLifecycle());
++    EXPECT_FALSE(getApp(apps, "unity7-package_single_x123")->info()
++                    ->supportsUbuntuLifecycle());
++    EXPECT_FALSE(getApp(apps, "unity7-package_multiple_x123")->info()
++                    ->supportsUbuntuLifecycle());
++
++    EXPECT_TRUE(std::dynamic_pointer_cast<ubuntu::app_launch::app_info::Desktop>(getApp(apps, "x11-package_multiple_x123")->info())
++                    ->xMirEnable());
++    EXPECT_TRUE(std::dynamic_pointer_cast<ubuntu::app_launch::app_info::Desktop>(getApp(apps, "unity7-package_single_x123")->info())
++                    ->xMirEnable());
++    EXPECT_TRUE(std::dynamic_pointer_cast<ubuntu::app_launch::app_info::Desktop>(getApp(apps, "unity8-package_foo_x123")->info())
++                    ->xMirEnable());
++    EXPECT_FALSE(std::dynamic_pointer_cast<ubuntu::app_launch::app_info::Desktop>(getApp(apps, "unity8-package_qmlapp_x123")->info())
++                    ->xMirEnable());
+ }
  #endif
@@ -272,9 +278,10 @@
+ {
  #ifdef ENABLE_SNAPPY
      SnapdMock mock{SNAPD_LIST_APPS_SOCKET,
--                   {interfaces, u8Package, u8Package, u8Package,                       /* unity8 check */
++                   {interfaces, u8Package, /* unity8 check */
++                    interfaces, u8Package, u8Package, /* mir check */
                      interfaces, u8Package, u7Package, u7Package, u7Package, u8Package, /* unity7 check */
--                    interfaces, x11Package, x11Package, x11Package}};                  /* x11 check */
++                    interfaces, x11Package, x11Package, x11Package}}; /* x11 check */
  #endif
      auto registry = std::make_shared<ubuntu::app_launch::Registry>();
@@ -284,7 +291,7 @@
      printApps(apps);
  #ifdef ENABLE_SNAPPY
--    EXPECT_EQ(19, int(apps.size()));
++    EXPECT_EQ(20, int(apps.size()));
  #else
      EXPECT_EQ(15, int(apps.size()));
  #endif