Merge lp:~ted/ubuntu-app-launch/app-object-signals into lp:ubuntu-app-launch/16.10

[Ted Gould]

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:232
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~ted/ubuntu-app-launch/app-object-signals/+merge/294807/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-ci/55/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-amd64-ci/55/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-armhf-ci/55/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-i386-ci/55/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-app-launch-ci/55/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/app-object-signals]

234. By Ted Gould on 2016-05-16

Updated to trunk

235. By Ted Gould on 2016-05-16

Make the signal access functions

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:234
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~ted/ubuntu-app-launch/app-object-signals/+merge/294807/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-ci/56/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-amd64-ci/56
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-armhf-ci/56
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-i386-ci/56

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-app-launch-ci/56/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:235
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~ted/ubuntu-app-launch/app-object-signals/+merge/294807/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-ci/57/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-amd64-ci/57
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-armhf-ci/57
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-i386-ci/57

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-app-launch-ci/57/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/app-object-signals]

236. By Ted Gould on 2016-05-17

Adding in stubs to bring out the implementation

237. By Ted Gould on 2016-10-27

Merging trunk

238. By Ted Gould on 2016-10-27

Move the signal functions into the implementation

239. By Ted Gould on 2016-10-27

Building a place to register signals

240. By Ted Gould on 2016-10-27

Code up starting and stopping, some TODOs

241. By Ted Gould on 2016-10-28

Port over app started and stopped to C++ interfaces

242. By Ted Gould on 2016-10-28

Switch to passing in the shared pointer to the registry

243. By Ted Gould on 2016-10-31

Make sure to grab a copy of the shared pointer

244. By Ted Gould on 2016-10-31

Move the greed around in our regex

245. By Ted Gould on 2016-10-31

Switching to a weak pointer

246. By Ted Gould on 2016-10-31

Make calls with the C library use the current context to not break existing code.

247. By Ted Gould on 2016-10-31

Moving over pause/resume

248. By Ted Gould on 2016-10-31

Fixing the watcher

249. By Ted Gould on 2016-10-31

Migrating over the failed signal

250. By Ted Gould on 2016-11-01

Apply formatting rules to tools

251. By Ted Gould on 2016-11-01

Print pids for pause/resume

252. By Ted Gould on 2016-11-01

Basic foundation for manager signals

253. By Ted Gould on 2016-11-01

Start to flesh out more of the resume request

254. By Ted Gould on 2016-11-01

Restructure to use more shared pointers

255. By Ted Gould on 2016-11-01

Switch the C code to using the manager interface

256. By Ted Gould on 2016-11-01

Fleshing out the focus handler

257. By Ted Gould on 2016-11-01

Add a handler for starting

258. By Ted Gould on 2016-11-02

Refactor into a shared function to do the longer dbus calls

259. By Ted Gould on 2016-11-02

Restructure so that we can call the right signal

260. By Ted Gould on 2016-11-02

Make it so that the manager observers execute on their context

261. By Ted Gould on 2016-11-02

Switch to using a global weak pointer so that it expires with the tracking of the Registry object

262. By Ted Gould on 2016-11-02

Clean up weak_ptr<> code

263. By Ted Gould on 2016-11-02

Make sure we wait to install the signals before returning

264. By Ted Gould on 2016-11-02

Put a warning in about thread safety

265. By Ted Gould on 2016-11-03

Port tests over to using a manager for focus events

266. By Ted Gould on 2016-11-04

Fixing the start and stop observer test

267. By Ted Gould on 2016-11-04

Fix the starting test

268. By Ted Gould on 2016-11-04

Failing test ported over

269. By Ted Gould on 2016-11-04

Documentation for registry functions

270. By Ted Gould on 2016-11-04

More comments

271. By Ted Gould on 2016-11-04

Variable comments

272. By Ted Gould on 2016-11-04

A comment on why this comment is there

273. By Ted Gould on 2016-11-07

Switch failure test over to using the C++ api

274. By Ted Gould on 2016-11-07

Making sure we connect the signals before returnning

275. By Ted Gould on 2016-11-07

Fix failure test environment and values to make them work as real applications

276. By Ted Gould on 2016-11-07

Apply formatting rules to failure-test.cc

277. By Ted Gould on 2016-11-10

Make gcc6 happy

278. By Ted Gould on 2016-11-11

Putting additional checks in to make sure we don't use null pointers we don't get locks on.

279. By Ted Gould on 2016-11-12

Ensure the manager thread shutsdown before the registry to avoid a deadlock

280. By Ted Gould on 2016-11-16

Merge future trunk

281. By Ted Gould on 2017-01-09

Remove some of the sing song part of the comments

282. By Ted Gould on 2017-01-09

Additional comment on lifecycle of replies

283. By Ted Gould on 2017-01-09

Zesty formatting tools diffs

284. By Ted Gould on 2017-01-09

Curly init

285. By Ted Gould on 2017-01-09

Make sure to check for a nullappid or error for g_variant_get()

286. By Ted Gould on 2017-01-09

Names of the parameters for clarity

287. By Ted Gould on 2017-01-09

Moar auto!

288. By Ted Gould on 2017-01-09

Don't specify returning void explicitly

289. By Ted Gould on 2017-01-09

Use static_cast() for void* casts

290. By Ted Gould on 2017-01-09

Don't spell well

291. By Ted Gould on 2017-01-09

Make sure to check for a valid registry

292. By Ted Gould on 2017-01-09

Comment out unused variables

293. By Ted Gould on 2017-01-09

Sometimes life would be better if it was more constant

294. By Ted Gould on 2017-01-09

Me no spell good

295. By Ted Gould on 2017-01-09

auto auto auto

296. By Ted Gould on 2017-01-09

Some 'NULL's crept in

297. By Ted Gould on 2017-01-09

More auto's with GVariants

298. By Ted Gould on 2017-01-09

Make params constant

299. By Ted Gould on 2017-01-09

Change setManager to have const& parameters

300. By Ted Gould on 2017-01-09

Fix the API so that the signal callbacks take pointers

301. By Ted Gould on 2017-01-10

Note it is on the UAL thread only

302. By Ted Gould on 2017-01-10

Save some stack data with this context

303. By Ted Gould on 2017-01-10

Formatting fix

304. By Ted Gould on 2017-01-10

Use an ensure_cmanager() helper to remove duplicate code

305. By Ted Gould on 2017-01-10

Putting all the map handling code in a couple templates

306. By Ted Gould on 2017-01-10

Pull out the request code into individual functions

307. By Ted Gould on 2017-01-10

Rename a function and add comments

308. By Ted Gould on 2017-01-10

Expand the usage of observer_delete

309. By Ted Gould on 2017-01-11

Factor out pause/resume commonality

310. By Ted Gould on 2017-01-11

I've been overrided by charles

311. By Ted Gould on 2017-01-19

Update to trunk

312. By Ted Gould on 2017-01-23

Adding virtual destructors, acc says they're fine.

313. By Ted Gould on 2017-01-24

Putting this off for gcc 5.4

314. By Ted Gould on 2017-01-24

Block off more API breaks this time

Unmerged revisions

314. By Ted Gould on 2017-01-24

Block off more API breaks this time

313. By Ted Gould on 2017-01-24

Putting this off for gcc 5.4

312. By Ted Gould on 2017-01-23

Adding virtual destructors, acc says they're fine.

311. By Ted Gould on 2017-01-19

Update to trunk

310. By Ted Gould on 2017-01-11

I've been overrided by charles

309. By Ted Gould on 2017-01-11

Factor out pause/resume commonality

308. By Ted Gould on 2017-01-10

Expand the usage of observer_delete

307. By Ted Gould on 2017-01-10

Rename a function and add comments

306. By Ted Gould on 2017-01-10

Pull out the request code into individual functions

305. By Ted Gould on 2017-01-10

Putting all the map handling code in a couple templates

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-11-07 20:56:13 +0000
@@ -255,8 +255,7 @@
             }
             catch (std::runtime_error& e)
             {
-                g_debug("Unable to create application for libertine appname '%s': %s",
-                        apps.get()[j], e.what());
+                g_debug("Unable to create application for libertine appname '%s': %s", apps.get()[j], e.what());
             }
         }
     }
 
=== modified file 'libubuntu-app-launch/libubuntu-app-launch.map'
--- libubuntu-app-launch/libubuntu-app-launch.map	2016-05-19 16:24:11 +0000
+++ libubuntu-app-launch/libubuntu-app-launch.map	2016-11-07 20:56:13 +0000
@@ -14,6 +14,7 @@
 		ubuntu::app_launch::Helper::*;
 		typeinfo?for?ubuntu::app_launch::Helper;
 		typeinfo?name?for?ubuntu::app_launch::Helper;
+		ubuntu::app_launch::operator*;
 		ubuntu::app_launch::oom::*;
 	};
 local:
 
=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-11-07 20:56:13 +0000
@@ -20,6 +20,7 @@
 #include "registry-impl.h"
 #include "application-icon-finder.h"
 #include <cgmanager/cgmanager.h>
+#include <regex>
 #include <upstart.h>
 
 namespace ubuntu
@@ -36,13 +37,29 @@
                  zgLog_.reset();
                  cgManager_.reset();
 
+                 auto dohandle = [&](guint& handle) {
+                     if (handle != 0)
+                     {
+                         g_dbus_connection_signal_unsubscribe(_dbus.get(), handle);
+                         handle = 0;
+                     }
+                 };
+
+                 dohandle(handle_appStarted);
+                 dohandle(handle_appStopped);
+                 dohandle(handle_appFailed);
+                 dohandle(handle_appPaused);
+                 dohandle(handle_appResumed);
+                 dohandle(handle_managerSignalFocus);
+                 dohandle(handle_managerSignalResume);
+                 dohandle(handle_managerSignalStarting);
+
                  if (_dbus)
                      g_dbus_connection_flush_sync(_dbus.get(), nullptr, nullptr);
                  _dbus.reset();
              })
     , _registry(registry)
     , _iconFinders()
-// _manager(nullptr)
 {
     auto cancel = thread.getCancellable();
     _dbus = thread.executeOnThread<std::shared_ptr<GDBusConnection>>([cancel]() {
@@ -536,24 +553,193 @@
     return _iconFinders[basePath];
 }
 
-#if 0
-void
-Registry::Impl::setManager (Registry::Manager* manager)
-{
-    if (_manager != nullptr)
+/** Structure to track the data needed for upstart events. This cleans
+    up the lifecycle as we're passing this as a pointer through the
+    GLib calls. */
+struct upstartEventData
+{
+    /** Keeping a weak pointer because the handle is held by
+        the registry implementation. */
+    std::weak_ptr<Registry> weakReg;
+};
+
+/** Take the GVariant of parameters and turn them into an application and
+    and instance. Easier to read in the smaller function */
+std::tuple<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> Registry::Impl::managerParams(
+    const std::shared_ptr<GVariant>& params, const std::shared_ptr<Registry>& reg)
+{
+    std::shared_ptr<Application> app;
+    std::shared_ptr<Application::Instance> instance;
+
+    const gchar* cappid = nullptr;
+    g_variant_get(params.get(), "(&s)", &cappid);
+
+    auto appid = ubuntu::app_launch::AppID::find(reg, cappid);
+    app = ubuntu::app_launch::Application::create(appid, reg);
+
+    return std::make_tuple(app, instance);
+}
+
+/** Used to store data for manager based signal handlers. Has a link to the
+    registry and the callback to use in a C++ style. */
+struct managerEventData
+{
+    /* Keeping a weak pointer because the handle is held by
+       the registry implementation. */
+    std::weak_ptr<Registry> weakReg;
+    std::function<void(const std::shared_ptr<Registry>& reg,
+                       const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>&,
+                       const std::string&,
+                       const std::shared_ptr<GVariant>&)>
+        func;
+};
+
+/** Register for a signal for the manager. All of the signals needed this same
+    code so it got pulled out into a function. Takes the same of the signal, the registry
+    that we're using and a function to call after we've messaged all the parameters
+    into being something C++-ish. */
+guint Registry::Impl::managerSignalHelper(const std::shared_ptr<Registry>& reg,
+                                          const std::string& signalname,
+                                          std::function<void(const std::shared_ptr<Registry>& reg,
+                                                             const std::shared_ptr<Application>& app,
+                                                             const std::shared_ptr<Application::Instance>& instance,
+                                                             const std::shared_ptr<GDBusConnection>&,
+                                                             const std::string&,
+                                                             const std::shared_ptr<GVariant>&)> responsefunc)
+{
+    managerEventData* focusdata = new managerEventData{reg, responsefunc};
+
+    return g_dbus_connection_signal_subscribe(
+        reg->impl->_dbus.get(),          /* bus */
+        nullptr,                         /* sender */
+        "com.canonical.UbuntuAppLaunch", /* interface */
+        signalname.c_str(),              /* signal */
+        "/",                             /* path */
+        nullptr,                         /* arg0 */
+        G_DBUS_SIGNAL_FLAGS_NONE,
+        [](GDBusConnection* cconn, const gchar* csender, const gchar*, const gchar*, const gchar*, GVariant* params,
+           gpointer user_data) -> void {
+            auto data = reinterpret_cast<managerEventData*>(user_data);
+            auto reg = data->weakReg.lock();
+
+            /* If we're still conneted and the manager has been cleared
+               we'll just be a no-op */
+            if (!reg->impl->manager_)
+            {
+                return;
+            }
+
+            auto vparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+            auto conn = std::shared_ptr<GDBusConnection>(reinterpret_cast<GDBusConnection*>(g_object_ref(cconn)),
+                                                         [](GDBusConnection* con) { g_clear_object(&con); });
+            std::string sender = csender;
+            std::shared_ptr<Application> app;
+            std::shared_ptr<Application::Instance> instance;
+
+            std::tie(app, instance) = managerParams(vparams, reg);
+
+            data->func(reg, app, instance, conn, sender, vparams);
+        },
+        focusdata,
+        [](gpointer user_data) {
+            auto data = reinterpret_cast<managerEventData*>(user_data);
+            delete data;
+        }); /* user data destroy */
+}
+
+/** Set the manager for the registry. This includes tracking the pointer
+    as well as setting up the signals to call back into the manager. The
+    signals are only setup once per registry even if the manager is cleared
+    and changed again. They will just be no-op's in those cases.
+*/
+void Registry::Impl::setManager(std::shared_ptr<Registry::Manager> manager, std::shared_ptr<Registry> reg)
+{
+    if (reg->impl->manager_)
     {
         throw std::runtime_error("Already have a manager and trying to set another");
     }
 
-    _manager = manager;
+    g_debug("Setting a new manager");
+    reg->impl->manager_ = manager;
+
+    std::call_once(reg->impl->flag_managerSignals, [reg]() {
+        if (!reg->impl->thread.executeOnThread<bool>([reg]() {
+                reg->impl->handle_managerSignalFocus = managerSignalHelper(
+                    reg, "UnityFocusRequest",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+                        /* Nothing to do today */
+                        reg->impl->manager_->focusRequest(app, instance, [](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                        });
+                    });
+                reg->impl->handle_managerSignalStarting = managerSignalHelper(
+                    reg, "UnityStartingBroadcast",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+
+                        reg->impl->manager_->startingRequest(app, instance, [conn, sender, params](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                            if (response)
+                            {
+                                g_dbus_connection_emit_signal(conn.get(), sender.c_str(),      /* destination */
+                                                              "/",                             /* path */
+                                                              "com.canonical.UbuntuAppLaunch", /* interface */
+                                                              "UnityStartingSignal",           /* signal */
+                                                              params.get(),                    /* params, the same */
+                                                              nullptr);                        /* error */
+                            }
+                        });
+                    });
+                reg->impl->handle_managerSignalResume = managerSignalHelper(
+                    reg, "UnityResumeRequest",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+                        reg->impl->manager_->resumeRequest(app, instance, [conn, sender, params](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                            if (response)
+                            {
+                                g_dbus_connection_emit_signal(conn.get(), sender.c_str(),      /* destination */
+                                                              "/",                             /* path */
+                                                              "com.canonical.UbuntuAppLaunch", /* interface */
+                                                              "UnityResumeResponse",           /* signal */
+                                                              params.get(),                    /* params, the same */
+                                                              nullptr);                        /* error */
+                            }
+                        });
+                    });
+
+                return true;
+            }))
+        {
+            g_warning("Unable to install manager signals");
+        }
+    });
 }
 
-void
-Registry::Impl::clearManager ()
+/** Clear the manager pointer */
+void Registry::Impl::clearManager()
 {
-    _manager = nullptr;
+    g_debug("Clearing the manager");
+    manager_.reset();
 }
-#endif
 
 /** App start watching, if we're registered for the signal we
     can't wait on it. We are making this static right now because
@@ -576,5 +762,301 @@
     return watchingAppStarting_;
 }
 
+/** Regex to parse the JOB environment variable from Upstart */
+std::regex jobenv_regex{"^JOB=(application\\-(?:click|snap|legacy))$"};
+/** Regex to parse the INSTANCE environment variable from Upstart */
+std::regex instanceenv_regex{"^INSTANCE=(.*?)(?:\\-([0-9]*))?+$"};
+
+/** Core of most of the events that come from Upstart directly. Includes parsing of the
+    Upstart event environment and calling the appropriate signal with the right Application
+    object and eventually its instance */
+void Registry::Impl::upstartEventEmitted(
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& signal,
+    std::shared_ptr<GVariant> params,
+    const std::shared_ptr<Registry>& reg)
+{
+    std::string jobname;
+    std::string sappid;
+    std::string instance;
+
+    gchar* env = nullptr;
+    GVariant* envs = g_variant_get_child_value(params.get(), 1);
+    GVariantIter iter;
+    g_variant_iter_init(&iter, envs);
+
+    while (g_variant_iter_loop(&iter, "s", &env))
+    {
+        std::smatch match;
+        std::string senv = env;
+
+        if (std::regex_match(senv, match, jobenv_regex))
+        {
+            jobname = match[1].str();
+        }
+        else if (std::regex_match(senv, match, instanceenv_regex))
+        {
+            sappid = match[1].str();
+            instance = match[2].str();
+        }
+    }
+
+    g_variant_unref(envs);
+
+    if (jobname.empty())
+    {
+        return;
+    }
+
+    g_debug("Upstart Event for job '%s' appid '%s' instance '%s'", jobname.c_str(), sappid.c_str(), instance.c_str());
+
+    auto appid = AppID::find(reg, sappid);
+    auto app = Application::create(appid, reg);
+
+    // TODO: Figure otu creating instances
+
+    signal(app, {});
+}
+
+/** Grab the signal object for application startup. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::Impl::appStarted(
+    const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appStarted, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appStarted = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(), /* bus */
+                nullptr,                /* sender */
+                DBUS_INTERFACE_UPSTART, /* interface */
+                "EventEmitted",         /* signal */
+                DBUS_PATH_UPSTART,      /* path */
+                "started",              /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->upstartEventEmitted(reg->impl->sig_appStarted, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appStarted;
+}
+
+/** Grab the signal object for application stopping. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::Impl::appStopped(
+    const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appStopped, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appStopped = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(), /* bus */
+                nullptr,                /* sender */
+                DBUS_INTERFACE_UPSTART, /* interface */
+                "EventEmitted",         /* signal */
+                DBUS_PATH_UPSTART,      /* path */
+                "stopped",              /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->upstartEventEmitted(reg->impl->sig_appStopped, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appStopped;
+}
+
+/** Grab the signal object for application failing. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+    Registry::Impl::appFailed(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appFailed, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appFailed = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationFailed",             /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+
+                    const gchar* sappid = NULL;
+                    const gchar* typestr = NULL;
+
+                    Registry::FailureType type = Registry::FailureType::CRASH;
+                    g_variant_get(params, "(&s&s)", &sappid, &typestr);
+
+                    if (g_strcmp0("crash", typestr) == 0)
+                    {
+                        type = Registry::FailureType::CRASH;
+                    }
+                    else if (g_strcmp0("start-failure", typestr) == 0)
+                    {
+                        type = Registry::FailureType::START_FAILURE;
+                    }
+                    else
+                    {
+                        g_warning("Application failure type '%s' unknown, reporting as a crash", typestr);
+                    }
+
+                    auto appid = AppID::find(reg, sappid);
+                    auto app = Application::create(appid, reg);
+
+                    /* TODO: Instance issues */
+
+                    reg->impl->sig_appFailed(app, {}, type);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appFailed;
+}
+
+/** Core handler for pause and resume events. Includes turning the GVariant
+    pid list into a std::vector and getting the application object. */
+void Registry::Impl::pauseEventEmitted(
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& signal,
+    const std::shared_ptr<GVariant>& params,
+    const std::shared_ptr<Registry>& reg)
+{
+    std::vector<pid_t> pids;
+    GVariant* vappid = g_variant_get_child_value(params.get(), 0);
+    GVariant* vpids = g_variant_get_child_value(params.get(), 1);
+    guint64 pid;
+    GVariantIter thispid;
+    g_variant_iter_init(&thispid, vpids);
+
+    while (g_variant_iter_loop(&thispid, "t", &pid))
+    {
+        pids.emplace_back(pid);
+    }
+
+    auto cappid = g_variant_get_string(vappid, NULL);
+    auto appid = ubuntu::app_launch::AppID::find(reg, cappid);
+    auto app = Application::create(appid, reg);
+
+    /* TODO: Instance */
+    signal(app, {}, pids);
+
+    g_variant_unref(vappid);
+    g_variant_unref(vpids);
+
+    return;
+}
+
+/** Grab the signal object for application paused. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::Impl::appPaused(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appPaused, [&]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appPaused = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationPaused",             /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->pauseEventEmitted(reg->impl->sig_appPaused, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appPaused;
+}
+
+/** Grab the signal object for application resumed. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::Impl::appResumed(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appResumed, [&]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appResumed = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationResumed",            /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->pauseEventEmitted(reg->impl->sig_appResumed, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appResumed;
+}
+
 }  // namespace app_launch
 }  // namespace ubuntu
 
=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-11-07 20:56:13 +0000
@@ -53,10 +53,8 @@
     std::list<AppID::Package> getClickPackages();
     std::string getClickDir(const std::string& package);
 
-#if 0
-    void setManager (Registry::Manager* manager);
-    void clearManager ();
-#endif
+    static void setManager(std::shared_ptr<Registry::Manager> manager, std::shared_ptr<Registry> registry);
+    void clearManager();
 
     /** Shared context thread for events and background tasks
         that UAL subtasks are doing */
@@ -82,6 +80,18 @@
     static std::string printJson(std::shared_ptr<JsonObject> jsonobj);
     static std::string printJson(std::shared_ptr<JsonNode> jsonnode);
 
+    /* Signals to discover what is happening to apps */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStarted(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStopped(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType>& appFailed(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& appPaused(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& appResumed(
+        const std::shared_ptr<Registry>& reg);
+
     /* Signal Hints */
     /* NOTE: Static because we don't have registry instances in the C
        code right now. We want these to not be static in the future */
@@ -89,22 +99,77 @@
     static bool isWatchingAppStarting();
 
 private:
-    Registry* _registry;
-#if 0
-    Registry::Manager* _manager;
-#endif
-
-    std::shared_ptr<ClickDB> _clickDB;
-    std::shared_ptr<ClickUser> _clickUser;
+    Registry* _registry;                         /**< The Registry that we're spawned from */
+    std::shared_ptr<Registry::Manager> manager_; /**< Application manager if registered */
+
+    std::shared_ptr<ClickDB> _clickDB;     /**< Shared instance of the Click Database */
+    std::shared_ptr<ClickUser> _clickUser; /**< Click database filtered by the current user */
+
+    /** Signal object for applications started */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> sig_appStarted;
+    /** Signal object for applications stopped */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> sig_appStopped;
+    /** Signal object for applications failed */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType> sig_appFailed;
+    /** Signal object for applications paused */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>
+        sig_appPaused;
+    /** Signal object for applications resumed */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>
+        sig_appResumed;
+
+    guint handle_appStarted{0};            /**< GDBus signal watcher handle for app started signal */
+    guint handle_appStopped{0};            /**< GDBus signal watcher handle for app stopped signal */
+    guint handle_appFailed{0};             /**< GDBus signal watcher handle for app failed signal */
+    guint handle_appPaused{0};             /**< GDBus signal watcher handle for app paused signal */
+    guint handle_appResumed{0};            /**< GDBus signal watcher handle for app resumed signal */
+    guint handle_managerSignalFocus{0};    /**< GDBus signal watcher handle for app focused signal */
+    guint handle_managerSignalResume{0};   /**< GDBus signal watcher handle for app resumed signal */
+    guint handle_managerSignalStarting{0}; /**< GDBus signal watcher handle for app starting signal */
+
+    std::once_flag flag_appStarted; /**< Variable to track to see if signal handlers are installed for application
+                                       started */
+    std::once_flag flag_appStopped; /**< Variable to track to see if signal handlers are installed for application
+                                       stopped */
+    std::once_flag
+        flag_appFailed; /**< Variable to track to see if signal handlers are installed for application failed */
+    std::once_flag
+        flag_appPaused; /**< Variable to track to see if signal handlers are installed for application paused */
+    std::once_flag flag_appResumed;     /**< Variable to track to see if signal handlers are installed for application
+                                           resumed */
+    std::once_flag flag_managerSignals; /**< Variable to track to see if signal handlers are installed for the manager
+                                           signals of focused, resumed and starting */
+
+    void upstartEventEmitted(core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& signal,
+                             std::shared_ptr<GVariant> params,
+                             const std::shared_ptr<Registry>& reg);
+    void pauseEventEmitted(
+        core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& signal,
+        const std::shared_ptr<GVariant>& params,
+        const std::shared_ptr<Registry>& reg);
+    static std::tuple<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> managerParams(
+        const std::shared_ptr<GVariant>& params, const std::shared_ptr<Registry>& reg);
+    static guint managerSignalHelper(const std::shared_ptr<Registry>& reg,
+                                     const std::string& signalname,
+                                     std::function<void(const std::shared_ptr<Registry>& reg,
+                                                        const std::shared_ptr<Application>& app,
+                                                        const std::shared_ptr<Application::Instance>& instance,
+                                                        const std::shared_ptr<GDBusConnection>&,
+                                                        const std::string&,
+                                                        const std::shared_ptr<GVariant>&)> responsefunc);
 
     void initClick();
 
+    /** Shared instance of the Zeitgeist Log */
     std::shared_ptr<ZeitgeistLog> zgLog_;
 
+    /** Shared connection to CGManager */
     std::shared_ptr<GDBusConnection> cgManager_;
 
     void initCGManager();
 
+    /** All of our icon finders based on the path that they're looking
+        into */
     std::unordered_map<std::string, std::shared_ptr<IconFinder>> _iconFinders;
 
     /** Getting the Upstart job path is relatively expensive in
 
=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/registry.cpp	2016-11-07 20:56:13 +0000
@@ -57,7 +57,7 @@
     instances.splice(instances.begin(), connection->impl->upstartInstancesForJob("application-snap"));
 
     /* Remove the instance ID */
-    std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string &instancename) -> std::string {
+    std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string& instancename) -> std::string {
         static const std::regex instanceregex("^(.*)-[0-9]*$");
         std::smatch match;
         if (std::regex_match(instancename, match, instanceregex))
@@ -87,7 +87,7 @@
 
     g_debug("Overall there are %d instances: %s", int(instanceset.size()),
             std::accumulate(instanceset.begin(), instanceset.end(), std::string{},
-                            [](const std::string &instr, std::string instance) {
+                            [](const std::string& instr, std::string instance) {
                                 return instr.empty() ? instance : instr + ", " + instance;
                             })
                 .c_str());
@@ -127,6 +127,16 @@
     return list;
 }
 
+void Registry::setManager(std::shared_ptr<Manager> manager, std::shared_ptr<Registry> registry)
+{
+    Registry::Impl::setManager(manager, registry);
+}
+
+void Registry::clearManager()
+{
+    impl->clearManager();
+}
+
 std::shared_ptr<Registry> defaultRegistry;
 std::shared_ptr<Registry> Registry::getDefault()
 {
@@ -143,5 +153,35 @@
     defaultRegistry.reset();
 }
 
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::appStarted(
+    const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appStarted(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::appStopped(
+    const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appStopped(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+    Registry::appFailed(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appFailed(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::appPaused(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appPaused(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::appResumed(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appResumed(reg);
+}
+
 }  // namespace app_launch
 }  // namespace ubuntu
 
=== modified file 'libubuntu-app-launch/registry.h'
--- libubuntu-app-launch/registry.h	2016-06-09 14:55:34 +0000
+++ libubuntu-app-launch/registry.h	2016-11-07 20:56:13 +0000
@@ -73,28 +73,134 @@
     */
     static std::list<std::shared_ptr<Application>> installedApps(std::shared_ptr<Registry> registry = getDefault());
 
-#if 0 /* TODO -- In next MR */
     /* Signals to discover what is happening to apps */
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appStarted;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appStopped;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType> appFailed;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appPaused;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appResumed;
-
-    /* The Application Manager, almost always if you're not Unity8, don't
-       use this API. Testing is a special case. */
+    /** Get the signal object that is signaled when an application has been
+        started.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStarted(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has stopped.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStopped(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has failed.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType>& appFailed(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has been
+        paused.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appPaused(const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has been
+        resumed.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appResumed(const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** The Application Manager, almost always if you're not Unity8, don't
+        use this API. Testing is a special case. Subclass this interface and
+        implement these functions.
+
+        Each function here is being passed a function object that takes a boolean
+        to reply. This will accept or reject the request. The function object
+        can be copied to another thread and executed if needed.
+    */
     class Manager
     {
-        virtual bool focusRequest (std::shared_ptr<Application> app, std::shared_ptr<Application::Instance> instance) = 0;
-        virtual bool startingRequest (std::shared_ptr<Application> app, std::shared_ptr<Application::Instance> instance) = 0;
+    public:
+        /** Application wishes to startup
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting startup
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to start
+        */
+        virtual void startingRequest(std::shared_ptr<Application> app,
+                                     std::shared_ptr<Application::Instance> instance,
+                                     std::function<void(bool)> reply) = 0;
+
+        /** Application wishes to have focus. Usually this occurs when
+            a URL for the application is activated and the running app is
+            requested.
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting focus
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to focus
+        */
+        virtual void focusRequest(std::shared_ptr<Application> app,
+                                  std::shared_ptr<Application::Instance> instance,
+                                  std::function<void(bool)> reply) = 0;
+
+        /** Application wishes to resume. Usually this occurs when
+            a URL for the application is activated and the running app is
+            requested.
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting resume
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to resume
+        */
+        virtual void resumeRequest(std::shared_ptr<Application> app,
+                                   std::shared_ptr<Application::Instance> instance,
+                                   std::function<void(bool)> reply) = 0;
 
     protected:
         Manager() = default;
     };
 
-    void setManager (Manager* manager);
-    void clearManager ();
-#endif
+    /** Set the manager of applications, which gives permissions for them to
+        start and gain focus. In almost all cases this should be Unity8 as it
+        will be controlling applications.
+
+        This function will failure if there is already a manager set.
+
+        \param manager A reference to the Manager object to call
+        \param registry Registry to register the manager on
+    */
+    static void setManager(std::shared_ptr<Manager> manager, std::shared_ptr<Registry> registry);
+
+    /** Remove the current manager on the registry */
+    void clearManager();
 
     /* Helper Lists */
     /** Get a list of all the helpers for a given helper type
 
=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-14 21:58:39 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-11-07 20:56:13 +0000
@@ -39,6 +39,7 @@
 #include "appid.h"
 #include "registry.h"
 #include "registry-impl.h"
+#include <algorithm>
 
 static void free_helper (gpointer value);
 int kill (pid_t pid, int signal) noexcept;
@@ -271,155 +272,210 @@
 	gpointer user_data;
 };
 
-/* The data we keep for each failed observer */
-typedef struct _paused_resumed_observer_t paused_resumed_observer_t;
-struct _paused_resumed_observer_t {
-	GDBusConnection * conn;
-	guint sighandle;
-	UbuntuAppLaunchAppPausedResumedObserver func;
-	gpointer user_data;
-	const gchar * lttng_signal;
-};
-
-/* The lists of Observers */
-static GList * starting_array = NULL;
-static GList * started_array = NULL;
-static GList * stop_array = NULL;
-static GList * focus_array = NULL;
-static GList * resume_array = NULL;
-static GList * failed_array = NULL;
-static GList * paused_array = NULL;
-static GList * resumed_array = NULL;
-
-static void
-observer_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	observer_t * observer = (observer_t *)user_data;
-
-	const gchar * signalname = NULL;
-	g_variant_get_child(params, 0, "&s", &signalname);
-
-	ual_tracepoint(observer_start, signalname);
-
-	gchar * env = NULL;
-	GVariant * envs = g_variant_get_child_value(params, 1);
-	GVariantIter iter;
-	g_variant_iter_init(&iter, envs);
-
-	gboolean job_found = FALSE;
-	gboolean job_legacy = FALSE;
-	gchar * instance = NULL;
-
-	while (g_variant_iter_loop(&iter, "s", &env)) {
-		if (g_strcmp0(env, "JOB=application-click") == 0) {
-			job_found = TRUE;
-		} else if (g_strcmp0(env, "JOB=application-legacy") == 0) {
-			job_found = TRUE;
-			job_legacy = TRUE;
-		} else if (g_strcmp0(env, "JOB=application-snap") == 0) {
-			job_found = TRUE;
-			job_legacy = TRUE;
-		} else if (g_str_has_prefix(env, "INSTANCE=")) {
-			instance = g_strdup(env + strlen("INSTANCE="));
-		}
-	}
-
-	g_variant_unref(envs);
-
-	if (job_legacy && instance != NULL) {
-		gchar * dash = g_strrstr(instance, "-");
-		if (dash != NULL) {
-			dash[0] = '\0';
-		}
-	}
-
-	if (job_found && instance != NULL) {
-		observer->func(instance, observer->user_data);
-	}
-
-	ual_tracepoint(observer_finish, signalname);
-
-	g_free(instance);
-}
-
-/* Creates the observer structure and registers for the signal with
-   GDBus so that we can get a callback */
-static gboolean
-add_app_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, const gchar * signal, GList ** list)
-{
-	GDBusConnection * conn = gdbus_upstart_ref();
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	observer_t * observert = g_new0(observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	*list = g_list_prepend(*list, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		DBUS_INTERFACE_UPSTART, /* interface */
-		"EventEmitted", /* signal */
-		DBUS_PATH_UPSTART, /* path */
-		signal, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		observer_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
+/* Function to take a work function and have it execute on a given
+   GMainContext */
+static void executeOnContext (std::shared_ptr<GMainContext> context, std::function<void()> work)
+{
+	if (!context) {
+		work();
+		return;
+	}
+
+    auto heapWork = new std::function<void()>(work);
+
+    auto source = std::shared_ptr<GSource>(g_idle_source_new(), [](GSource* src) { g_clear_pointer(&src, g_source_unref); });
+    g_source_set_callback(source.get(),
+                          [](gpointer data) {
+                              auto heapWork = static_cast<std::function<void()>*>(data);
+                              (*heapWork)();
+                              return G_SOURCE_REMOVE;
+                          },
+                          heapWork,
+                          [](gpointer data) {
+                              auto heapWork = static_cast<std::function<void()>*>(data);
+                              delete heapWork;
+                          });
+
+    g_source_attach(source.get(), context.get());
+}
+
+/* Map of all the observers listening for app started */
+static std::map<std::pair<UbuntuAppLaunchAppObserver, gpointer>, core::ScopedConnection> appStartedObservers;
 
 gboolean
 ubuntu_app_launch_observer_add_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_app_generic(observer, user_data, "started", &started_array);
-}
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appStartedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appStarted().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, observer, user_data]() {
+						observer(appid.c_str(), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
+}
+
+gboolean
+ubuntu_app_launch_observer_delete_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
+{
+	auto iter = appStartedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appStartedObservers.end()) {
+		return FALSE;
+	}
+
+	appStartedObservers.erase(iter);
+	return TRUE;
+}
+
+/* Map of all the observers listening for app stopped */
+static std::map<std::pair<UbuntuAppLaunchAppObserver, gpointer>, core::ScopedConnection> appStoppedObservers;
 
 gboolean
 ubuntu_app_launch_observer_add_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_app_generic(observer, user_data, "stopped", &stop_array);
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appStoppedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appStopped().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, observer, user_data]() {
+						observer(appid.c_str(), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
-/* Creates the observer structure and registers for the signal with
-   GDBus so that we can get a callback */
-static gboolean
-add_session_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, const gchar * signal, GList ** list, GDBusSignalCallback session_cb)
+gboolean
+ubuntu_app_launch_observer_delete_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	auto iter = appStoppedObservers.find(std::make_pair(observer, user_data));
 
-	if (conn == NULL) {
+	if (iter == appStoppedObservers.end()) {
 		return FALSE;
 	}
 
-	observer_t * observert = g_new0(observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	*list = g_list_prepend(*list, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		signal, /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		session_cb,
-		observert,
-		NULL); /* user data destroy */
-
+	appStoppedObservers.erase(iter);
 	return TRUE;
 }
 
+class CManager : public ubuntu::app_launch::Registry::Manager
+{
+public:
+	CManager () {
+		g_debug("Creating the CManager object");
+	}
+
+	void startingRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                     std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager starting: %s", sappid.c_str());
+
+		for (const auto &data : startingList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+	void focusRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                  std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                  std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager focus: %s", sappid.c_str());
+
+		for (const auto &data : focusList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+	void resumeRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                   std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                   std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager resume: %s", sappid.c_str());
+
+		for (const auto &data : resumeList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+private:
+	struct ObserverData {
+		UbuntuAppLaunchAppObserver observer;
+		gpointer user_data;
+		std::shared_ptr<GMainContext> context;
+
+		ObserverData(UbuntuAppLaunchAppObserver obs, gpointer ud)
+			: observer(obs)
+			, user_data(ud) {
+			context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+		}
+	};
+
+	std::list<ObserverData> focusList;
+	std::list<ObserverData> resumeList;
+	std::list<ObserverData> startingList;
+
+	bool removeList (std::list<ObserverData> &list, UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		auto iter = std::find_if(list.begin(), list.end(), [observer, user_data](const ObserverData &data) {
+			return data.observer == observer && data.user_data == user_data;
+		});
+
+		if (iter == list.end()) {
+			return false;
+		}
+
+		list.erase(iter);
+		return true;
+	}
+
+public:
+	void addFocus (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		focusList.emplace_back(ObserverData(observer, user_data));
+	}
+	void addResume (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		resumeList.emplace_back(ObserverData(observer, user_data));
+	}
+	void addStarting (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		startingList.emplace_back(ObserverData(observer, user_data));
+	}
+	bool deleteFocus (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(focusList, observer, user_data);
+	}
+	bool deleteResume (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(resumeList, observer, user_data);
+	}
+	bool deleteStarting (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(startingList, observer, user_data);
+	}
+};
+
+static std::weak_ptr<CManager> cmanager;
+
 /* Generic handler for a bunch of our signals */
 static inline void
 generic_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
@@ -433,328 +489,158 @@
 	}
 }
 
-/* Handle the focus signal when it occurs, call the observer */
-static void
-focus_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	ual_tracepoint(observer_start, "focus");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	ual_tracepoint(observer_finish, "focus");
-}
-
 gboolean
 ubuntu_app_launch_observer_add_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_session_generic(observer, user_data, "UnityFocusRequest", &focus_array, focus_signal_cb);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
+	manager->addFocus(observer, user_data);
+	return TRUE;
 }
 
-/* Handle the resume signal when it occurs, call the observer, then send a signal back when we're done */
-static void
-resume_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+gboolean
+ubuntu_app_launch_observer_delete_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	ual_tracepoint(observer_start, "resume");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	GError * error = NULL;
-	g_dbus_connection_emit_signal(conn,
-		sender, /* destination */
-		"/", /* path */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"UnityResumeResponse", /* signal */
-		params, /* params, the same */
-		&error);
-
-	if (error != NULL) {
-		g_warning("Unable to emit response signal: %s", error->message);
-		g_error_free(error);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
 	}
 
-	ual_tracepoint(observer_finish, "resume");
+	return manager->deleteFocus(observer, user_data) ? TRUE : FALSE;
 }
 
 gboolean
 ubuntu_app_launch_observer_add_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_session_generic(observer, user_data, "UnityResumeRequest", &resume_array, resume_signal_cb);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
+	manager->addResume(observer, user_data);
+	return TRUE;
 }
 
-/* Handle the starting signal when it occurs, call the observer, then send a signal back when we're done */
-static void
-starting_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+gboolean
+ubuntu_app_launch_observer_delete_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	ual_tracepoint(observer_start, "starting");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	GError * error = NULL;
-	g_dbus_connection_emit_signal(conn,
-		sender, /* destination */
-		"/", /* path */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"UnityStartingSignal", /* signal */
-		params, /* params, the same */
-		&error);
-
-	if (error != NULL) {
-		g_warning("Unable to emit response signal: %s", error->message);
-		g_error_free(error);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
 	}
 
-	ual_tracepoint(observer_finish, "starting");
+	return manager->deleteResume(observer, user_data) ? TRUE : FALSE;
 }
 
 gboolean
 ubuntu_app_launch_observer_add_app_starting (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
 	ubuntu::app_launch::Registry::Impl::watchingAppStarting(true);
-	return add_session_generic(observer, user_data, "UnityStartingBroadcast", &starting_array, starting_signal_cb);
-}
-
-/* Handle the failed signal when it occurs, call the observer */
-static void
-failed_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	failed_observer_t * observer = (failed_observer_t *)user_data;
-	const gchar * appid = NULL;
-	const gchar * typestr = NULL;
-
-	ual_tracepoint(observer_start, "failed");
-
-	if (observer->func != NULL) {
-		UbuntuAppLaunchAppFailed type = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
-		g_variant_get(params, "(&s&s)", &appid, &typestr);
-
-		if (g_strcmp0("crash", typestr) == 0) {
-			type = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
-		} else if (g_strcmp0("start-failure", typestr) == 0) {
-			type = UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE;
-		} else {
-			g_warning("Application failure type '%s' unknown, reporting as a crash", typestr);
-		}
-
-		observer->func(appid, type, observer->user_data);
-	}
-
-	ual_tracepoint(observer_finish, "failed");
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
-{
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	failed_observer_t * observert = g_new0(failed_observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	failed_array = g_list_prepend(failed_array, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"ApplicationFailed", /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		failed_signal_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
-
-/* Handle the paused signal when it occurs, call the observer */
-static void
-paused_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	paused_resumed_observer_t * observer = (paused_resumed_observer_t *)user_data;
-
-	ual_tracepoint(observer_start, observer->lttng_signal);
-
-	if (observer->func != NULL) {
-		GArray * pidarray = g_array_new(TRUE, TRUE, sizeof(GPid));
-		GVariant * appid = g_variant_get_child_value(params, 0);
-		GVariant * pids = g_variant_get_child_value(params, 1);
-		guint64 pid;
-		GVariantIter thispid;
-		g_variant_iter_init(&thispid, pids);
-
-		while (g_variant_iter_loop(&thispid, "t", &pid)) {
-			GPid gpid = (GPid)pid; /* Should be a no-op for most architectures, but just in case */
-			g_array_append_val(pidarray, gpid);
-		}
-
-		observer->func(g_variant_get_string(appid, NULL), (GPid *)pidarray->data, observer->user_data);
-
-		g_array_free(pidarray, TRUE);
-		g_variant_unref(appid);
-		g_variant_unref(pids);
-	}
-
-	ual_tracepoint(observer_finish, observer->lttng_signal);
-}
-
-static gboolean
-paused_resumed_generic (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data, GList ** queue, const gchar * signal_name, const gchar * lttng_signal)
-{
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	paused_resumed_observer_t * observert = g_new0(paused_resumed_observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-	observert->lttng_signal = lttng_signal;
-
-	*queue = g_list_prepend(*queue, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		signal_name, /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		paused_signal_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
-{
-	return paused_resumed_generic(observer, user_data, &paused_array, "ApplicationPaused", "paused");
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
-{
-	return paused_resumed_generic(observer, user_data, &resumed_array, "ApplicationResumed", "resumed");
-}
-
-static gboolean
-delete_app_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, GList ** list)
-{
-	observer_t * observert = NULL;
-	GList * look;
-
-	for (look = *list; look != NULL; look = g_list_next(look)) {
-		observert = (observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
-		return FALSE;
-	}
-
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	*list = g_list_delete_link(*list, look);
-
-	return TRUE;
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &started_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &stop_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &resume_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &focus_array);
+	manager->addStarting(observer, user_data);
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_starting (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
+	}
+
 	ubuntu::app_launch::Registry::Impl::watchingAppStarting(false);
-	return delete_app_generic(observer, user_data, &starting_array);
+	return manager->deleteStarting(observer, user_data) ? TRUE : FALSE;
+}
+
+/* Map of all the observers listening for app stopped */
+static std::map<std::pair<UbuntuAppLaunchAppFailedObserver, gpointer>, core::ScopedConnection> appFailedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
+{
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appFailedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appFailed().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, ubuntu::app_launch::Registry::FailureType type) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, type, observer, user_data]() {
+						UbuntuAppLaunchAppFailed ctype;
+
+						switch (type) {
+						case ubuntu::app_launch::Registry::FailureType::CRASH:
+							ctype = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
+							break;
+						case ubuntu::app_launch::Registry::FailureType::START_FAILURE:
+							ctype = UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE;
+							break;
+						}
+
+						observer(appid.c_str(), ctype, user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
 {
-	failed_observer_t * observert = NULL;
-	GList * look;
-
-	for (look = failed_array; look != NULL; look = g_list_next(look)) {
-		observert = (failed_observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
+	auto iter = appFailedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appFailedObservers.end()) {
 		return FALSE;
 	}
 
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	failed_array = g_list_delete_link(failed_array, look);
-
+	appFailedObservers.erase(iter);
 	return TRUE;
 }
 
-static gboolean
-paused_resumed_delete (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data, GList ** list)
+static std::map<std::pair<UbuntuAppLaunchAppPausedResumedObserver, gpointer>, core::ScopedConnection> appPausedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	paused_resumed_observer_t * observert = NULL;
-	GList * look;
-
-	for (look = *list; look != NULL; look = g_list_next(look)) {
-		observert = (paused_resumed_observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
-		return FALSE;
-	}
-
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	*list = g_list_delete_link(*list, look);
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appPausedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appPaused().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, std::vector<pid_t> &pids) {
+					std::vector<pid_t> lpids = pids;
+					lpids.emplace_back(0);
+
+					std::string appid = app->appId();
+
+					executeOnContext(context, [appid, observer, user_data, lpids]() {
+						observer(appid.c_str(), (int *)(lpids.data()), user_data);
+					});
+				})
+			)
+		));
 
 	return TRUE;
 }
@@ -762,13 +648,53 @@
 gboolean
 ubuntu_app_launch_observer_delete_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	return paused_resumed_delete(observer, user_data, &paused_array);
+	auto iter = appPausedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appPausedObservers.end()) {
+		return FALSE;
+	}
+
+	appPausedObservers.erase(iter);
+	return TRUE;
+}
+
+static std::map<std::pair<UbuntuAppLaunchAppPausedResumedObserver, gpointer>, core::ScopedConnection> appResumedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
+{
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appResumedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appResumed().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, std::vector<pid_t>& pids) {
+					std::vector<pid_t> lpids = pids;
+					lpids.emplace_back(0);
+
+					std::string appid = app->appId();
+
+					executeOnContext(context, [appid, observer, user_data, lpids]() {
+						observer(appid.c_str(), (int *)(lpids.data()), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	return paused_resumed_delete(observer, user_data, &resumed_array);
+	auto iter = appResumedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appResumedObservers.end()) {
+		return FALSE;
+	}
+
+	appResumedObservers.erase(iter);
+	return TRUE;
 }
 
 typedef void (*per_instance_func_t) (GDBusConnection * con, GVariant * prop_dict, gpointer user_data);
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-09-14 16:43:36 +0000
+++ tests/CMakeLists.txt	2016-11-07 20:56:13 +0000
@@ -157,6 +157,7 @@
 
 add_custom_target(format-tests
 	COMMAND clang-format -i -style=file
+	failure-test.cc
 	application-info-desktop.cpp
 	libual-cpp-test.cc
 	list-apps.cpp
 
=== modified file 'tests/failure-test.cc'
--- tests/failure-test.cc	2016-08-25 18:13:44 +0000
+++ tests/failure-test.cc	2016-11-07 20:56:13 +0000
@@ -17,120 +17,147 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "eventually-fixture.h"
+#include "registry.h"
+#include <gio/gio.h>
+#include <glib/gstdio.h>
 #include <gtest/gtest.h>
-#include <glib/gstdio.h>
-#include <gio/gio.h>
-#include <ubuntu-app-launch.h>
-#include "eventually-fixture.h"
 
 class FailureTest : public EventuallyFixture
 {
-	private:
-		GTestDBus * testbus = NULL;
-
-	protected:
-		virtual void SetUp() {
-			testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
-			g_test_dbus_up(testbus);
-		}
-
-		virtual void TearDown() {
-			g_test_dbus_down(testbus);
-			g_clear_object(&testbus);
-		}
+private:
+    GTestDBus* testbus = NULL;
+
+protected:
+    std::shared_ptr<ubuntu::app_launch::Registry> registry;
+
+    virtual void SetUp()
+    {
+        /* Click DB test mode */
+        g_setenv("TEST_CLICK_DB", "click-db-dir", TRUE);
+        g_setenv("TEST_CLICK_USER", "test-user", TRUE);
+
+        gchar* linkfarmpath = g_build_filename(CMAKE_SOURCE_DIR, "link-farm", NULL);
+        g_setenv("UBUNTU_APP_LAUNCH_LINK_FARM", linkfarmpath, TRUE);
+        g_free(linkfarmpath);
+
+        g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
+        g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
+        g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
+
+        testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
+        g_test_dbus_up(testbus);
+
+        registry = std::make_shared<ubuntu::app_launch::Registry>();
+    }
+
+    virtual void TearDown()
+    {
+        registry.reset();
+
+        g_test_dbus_down(testbus);
+        g_clear_object(&testbus);
+    }
 };
 
-static void
-failed_observer (const gchar * appid, UbuntuAppLaunchAppFailed reason, gpointer user_data)
-{
-	if (reason == UBUNTU_APP_LAUNCH_APP_FAILED_CRASH) {
-		std::string * last = static_cast<std::string *>(user_data);
-		*last = appid;
-	}
-}
-
 TEST_F(FailureTest, CrashTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-click", TRUE);
-	g_setenv("INSTANCE", "foo", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	last_observer.clear();
-	g_unsetenv("EXIT_STATUS");
-	g_setenv("EXIT_SIGNAL", "KILL", TRUE);
-
-	/* Signal based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+    g_setenv("EXIT_STATUS", "-100", TRUE);
+    g_setenv("JOB", "application-click", TRUE);
+    g_setenv("INSTANCE", "foo", TRUE);
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    /* Status based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
+
+    last_observer.clear();
+    g_unsetenv("EXIT_STATUS");
+    g_setenv("EXIT_SIGNAL", "KILL", TRUE);
+
+    /* Signal based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
 }
 
 TEST_F(FailureTest, LegacyTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-legacy", TRUE);
-	g_setenv("INSTANCE", "foo-1234", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+    g_setenv("EXIT_STATUS", "-100", TRUE);
+    g_setenv("JOB", "application-legacy", TRUE);
+    g_setenv("INSTANCE", "foo-1234", TRUE);
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            g_debug("Signal handler called");
+            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    /* Status based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
 }
 
 TEST_F(FailureTest, SnapTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-snap", TRUE);
-	g_setenv("INSTANCE", "foo_bar_x123-1234", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo_bar_x123", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
-}
-
-static void
-failed_start_observer (const gchar * appid, UbuntuAppLaunchAppFailed reason, gpointer user_data)
-{
-	if (reason == UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE) {
-		std::string * last = static_cast<std::string *>(user_data);
-		*last = appid;
-	}
+    g_setenv("EXIT_STATUS", "-100", TRUE);
+    g_setenv("JOB", "application-snap", TRUE);
+    g_setenv("INSTANCE", "com.test.good_application_1.2.3-1234", TRUE);
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    /* Status based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", last_observer);
 }
 
 TEST_F(FailureTest, StartTest)
 {
-	g_setenv("JOB", "application-click", TRUE);
-	g_setenv("INSTANCE", "foo", TRUE);
-	g_unsetenv("EXIT_STATUS");
-	g_unsetenv("EXIT_SIGNAL");
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_start_observer, &last_observer));
-
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_start_observer, &last_observer));
+    g_setenv("JOB", "application-click", TRUE);
+    g_setenv("INSTANCE", "foo", TRUE);
+    g_unsetenv("EXIT_STATUS");
+    g_unsetenv("EXIT_SIGNAL");
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            if (type == ubuntu::app_launch::Registry::FailureType::START_FAILURE)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
 }
 
=== modified file 'tests/libual-cpp-test.cc'
--- tests/libual-cpp-test.cc	2016-09-23 20:36:31 +0000
+++ tests/libual-cpp-test.cc	2016-11-07 20:56:13 +0000
@@ -49,32 +49,68 @@
     DbusTestDbusMock* mock = NULL;
     DbusTestDbusMock* cgmock = NULL;
     GDBusConnection* bus = NULL;
-    std::string last_focus_appid;
-    std::string last_resume_appid;
     guint resume_timeout = 0;
     std::shared_ptr<ubuntu::app_launch::Registry> registry;
 
-private:
-    static void focus_cb(const gchar* appid, gpointer user_data)
-    {
-        g_debug("Focus Callback: %s", appid);
-        LibUAL* _this = static_cast<LibUAL*>(user_data);
-        _this->last_focus_appid = appid;
-    }
-
-    static void resume_cb(const gchar* appid, gpointer user_data)
-    {
-        g_debug("Resume Callback: %s", appid);
-        LibUAL* _this = static_cast<LibUAL*>(user_data);
-        _this->last_resume_appid = appid;
-
-        if (_this->resume_timeout > 0)
-        {
-            _this->pause(_this->resume_timeout);
-        }
-    }
-
-protected:
+    class ManagerMock : public ubuntu::app_launch::Registry::Manager
+    {
+        GLib::ContextThread thread;
+
+    public:
+        ManagerMock()
+        {
+            g_debug("Building a Manager Mock");
+        }
+
+        ~ManagerMock()
+        {
+            g_debug("Freeing a Manager Mock");
+        }
+
+        ubuntu::app_launch::AppID lastStartedApp;
+        ubuntu::app_launch::AppID lastFocusedApp;
+        ubuntu::app_launch::AppID lastResumedApp;
+
+        bool startingResponse{true};
+        bool focusResponse{true};
+        bool resumeResponse{true};
+
+        std::chrono::milliseconds startingTimeout{0};
+        std::chrono::milliseconds focusTimeout{0};
+        std::chrono::milliseconds resumeTimeout{0};
+
+        void startingRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                             std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                             std::function<void(bool)> reply) override
+        {
+            thread.timeout(startingTimeout, [this, app, instance, reply]() {
+                lastStartedApp = app->appId();
+                reply(startingResponse);
+            });
+        }
+
+        void focusRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                          std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                          std::function<void(bool)> reply) override
+        {
+            thread.timeout(focusTimeout, [this, app, instance, reply]() {
+                lastFocusedApp = app->appId();
+                reply(focusResponse);
+            });
+        }
+
+        void resumeRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                           std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                           std::function<void(bool)> reply) override
+        {
+            thread.timeout(resumeTimeout, [this, app, instance, reply]() {
+                lastResumedApp = app->appId();
+                reply(resumeResponse);
+            });
+        }
+    };
+    std::weak_ptr<ManagerMock> manager;
+
     /* Useful debugging stuff, but not on by default.  You really want to
        not get all this noise typically */
     void debugConnection()
@@ -127,13 +163,13 @@
 
         dbus_test_dbus_mock_object_add_method(mock, obj, "GetJobByName", G_VARIANT_TYPE("s"), G_VARIANT_TYPE("o"),
                                               "if args[0] == 'application-click':\n"
-                                              "	ret = dbus.ObjectPath('/com/test/application_click')\n"
+                                              "    ret = dbus.ObjectPath('/com/test/application_click')\n"
                                               "elif args[0] == 'application-snap':\n"
-                                              "	ret = dbus.ObjectPath('/com/test/application_snap')\n"
+                                              "    ret = dbus.ObjectPath('/com/test/application_snap')\n"
                                               "elif args[0] == 'application-legacy':\n"
-                                              "	ret = dbus.ObjectPath('/com/test/application_legacy')\n"
+                                              "    ret = dbus.ObjectPath('/com/test/application_legacy')\n"
                                               "elif args[0] == 'untrusted-helper':\n"
-                                              "	ret = dbus.ObjectPath('/com/test/untrusted/helper')\n",
+                                              "    ret = dbus.ObjectPath('/com/test/untrusted/helper')\n",
                                               NULL);
 
         dbus_test_dbus_mock_object_add_method(mock, obj, "SetEnv", G_VARIANT_TYPE("(assb)"), NULL, "", NULL);
@@ -272,19 +308,23 @@
         /* Make sure we pretend the CG manager is just on our bus */
         g_setenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS", "YES", TRUE);
 
-        ASSERT_TRUE(ubuntu_app_launch_observer_add_app_focus(focus_cb, this));
-        ASSERT_TRUE(ubuntu_app_launch_observer_add_app_resume(resume_cb, this));
-
         registry = std::make_shared<ubuntu::app_launch::Registry>();
+
+        auto smanager = std::make_shared<ManagerMock>();
+        manager = smanager;
+        ubuntu::app_launch::Registry::setManager(smanager, registry);
     }
 
     virtual void TearDown()
     {
-        ubuntu_app_launch_observer_delete_app_focus(focus_cb, this);
-        ubuntu_app_launch_observer_delete_app_resume(resume_cb, this);
-
         registry.reset();
 
+        // NOTE: This should generally always be commented out, but
+        // it is useful for debugging common errors, so leaving it
+        // as a comment to make debugging those eaiser.
+        //
+        // ubuntu::app_launch::Registry::clearDefault();
+
         g_clear_object(&mock);
         g_clear_object(&cgmock);
         g_clear_object(&service);
@@ -793,33 +833,30 @@
 #endif
 }
 
-typedef struct
-{
-    unsigned int count;
-    const gchar* name;
-} observer_data_t;
-
-static void observer_cb(const gchar* appid, gpointer user_data)
-{
-    observer_data_t* data = (observer_data_t*)user_data;
-
-    if (data->name == NULL)
-    {
-        data->count++;
-    }
-    else if (g_strcmp0(data->name, appid) == 0)
-    {
-        data->count++;
-    }
-}
-
 TEST_F(LibUAL, StartStopObserver)
 {
-    observer_data_t start_data = {.count = 0, .name = nullptr};
-    observer_data_t stop_data = {.count = 0, .name = nullptr};
-
-    ASSERT_TRUE(ubuntu_app_launch_observer_add_app_started(observer_cb, &start_data));
-    ASSERT_TRUE(ubuntu_app_launch_observer_add_app_stop(observer_cb, &stop_data));
+    int start_count = 0;
+    int stop_count = 0;
+    ubuntu::app_launch::AppID start_appid;
+    ubuntu::app_launch::AppID stop_appid;
+
+    ubuntu::app_launch::Registry::appStarted(registry).connect(
+        [&start_count, &start_appid](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+            if (!start_appid.empty() && !(start_appid == app->appId()))
+                return;
+
+            start_count++;
+        });
+
+    ubuntu::app_launch::Registry::appStopped(registry).connect(
+        [&stop_count, &stop_appid](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                   std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+            if (!stop_appid.empty() && !(stop_appid == app->appId()))
+                return;
+
+            stop_count++;
+        });
 
     DbusTestDbusMockObject* obj =
         dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
@@ -830,7 +867,7 @@
         g_variant_new_parsed("('started', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
         NULL);
 
-    EXPECT_EVENTUALLY_EQ(1, start_data.count);
+    EXPECT_EVENTUALLY_EQ(1, start_count);
 
     /* Basic stop */
     dbus_test_dbus_mock_object_emit_signal(
@@ -838,33 +875,41 @@
         g_variant_new_parsed("('stopped', ['JOB=application-click', 'INSTANCE=com.test.good_application_1.2.3'])"),
         NULL);
 
-    EXPECT_EVENTUALLY_EQ(1, stop_data.count);
+    EXPECT_EVENTUALLY_EQ(1, stop_count);
 
     /* Start legacy */
-    start_data.count = 0;
-    start_data.name = "multiple";
+    start_count = 0;
+    start_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw({}),
+                                            ubuntu::app_launch::AppID::AppName::from_raw("multiple"),
+                                            ubuntu::app_launch::AppID::Version::from_raw({})};
 
     dbus_test_dbus_mock_object_emit_signal(
         mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
         g_variant_new_parsed("('started', ['JOB=application-legacy', 'INSTANCE=multiple-234235'])"), NULL);
 
-    EXPECT_EVENTUALLY_EQ(1, start_data.count);
+    EXPECT_EVENTUALLY_EQ(1, start_count);
 
     /* Legacy stop */
-    stop_data.count = 0;
-    stop_data.name = "bar";
+    stop_count = 0;
+    stop_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw({}),
+                                           ubuntu::app_launch::AppID::AppName::from_raw("foo"),
+                                           ubuntu::app_launch::AppID::Version::from_raw({})};
 
     dbus_test_dbus_mock_object_emit_signal(
         mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"),
-        g_variant_new_parsed("('stopped', ['JOB=application-legacy', 'INSTANCE=bar-9344321'])"), NULL);
+        g_variant_new_parsed("('stopped', ['JOB=application-legacy', 'INSTANCE=foo-9344321'])"), NULL);
 
-    EXPECT_EVENTUALLY_EQ(1, stop_data.count);
+    EXPECT_EVENTUALLY_EQ(1, stop_count);
 
     /* Test Noise Start */
-    start_data.count = 0;
-    start_data.name = "com.test.good_application_1.2.3";
-    stop_data.count = 0;
-    stop_data.name = "com.test.good_application_1.2.3";
+    start_count = 0;
+    start_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw("com.test.good"),
+                                            ubuntu::app_launch::AppID::AppName::from_raw("application"),
+                                            ubuntu::app_launch::AppID::Version::from_raw("1.2.3")};
+    stop_count = 0;
+    stop_appid = ubuntu::app_launch::AppID{ubuntu::app_launch::AppID::Package::from_raw("com.test.good"),
+                                           ubuntu::app_launch::AppID::AppName::from_raw("application"),
+                                           ubuntu::app_launch::AppID::Version::from_raw("1.2.3")};
 
     /* A full lifecycle */
     dbus_test_dbus_mock_object_emit_signal(
@@ -885,46 +930,33 @@
         NULL);
 
     /* Ensure we just signaled once for each */
-    EXPECT_EVENTUALLY_EQ(1, start_data.count);
-    EXPECT_EVENTUALLY_EQ(1, stop_data.count);
-
-    /* Remove */
-    ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_started(observer_cb, &start_data));
-    ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_stop(observer_cb, &stop_data));
-}
-
-static GDBusMessage* filter_starting(GDBusConnection* conn,
-                                     GDBusMessage* message,
-                                     gboolean incomming,
-                                     gpointer user_data)
-{
-    if (g_strcmp0(g_dbus_message_get_member(message), "UnityStartingSignal") == 0)
-    {
-        unsigned int* count = static_cast<unsigned int*>(user_data);
-        (*count)++;
-        g_object_unref(message);
-        return NULL;
-    }
-
-    return message;
-}
-
-static void starting_observer(const gchar* appid, gpointer user_data)
-{
-    std::string* last = static_cast<std::string*>(user_data);
-    *last = appid;
-    return;
+    EXPECT_EVENTUALLY_EQ(1, start_count);
+    EXPECT_EVENTUALLY_EQ(1, stop_count);
 }
 
 TEST_F(LibUAL, StartingResponses)
 {
-    std::string last_observer;
+    /* Get Bus */
+    GDBusConnection* session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+    /* Setup filter to count signals out */
     unsigned int starting_count = 0;
-    GDBusConnection* session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-    guint filter = g_dbus_connection_add_filter(session, filter_starting, &starting_count, NULL);
-
-    EXPECT_TRUE(ubuntu_app_launch_observer_add_app_starting(starting_observer, &last_observer));
-
+    guint filter = g_dbus_connection_add_filter(
+        session,
+        [](GDBusConnection* conn, GDBusMessage* message, gboolean incomming, gpointer user_data) -> GDBusMessage* {
+            if (g_strcmp0(g_dbus_message_get_member(message), "UnityStartingSignal") == 0)
+            {
+                unsigned int* count = static_cast<unsigned int*>(user_data);
+                (*count)++;
+                g_object_unref(message);
+                return NULL;
+            }
+
+            return message;
+        },
+        &starting_count, NULL);
+
+    /* Emit a signal */
     g_dbus_connection_emit_signal(session, NULL,                                           /* destination */
                                   "/",                                                     /* path */
                                   "com.canonical.UbuntuAppLaunch",                         /* interface */
@@ -932,11 +964,15 @@
                                   g_variant_new("(s)", "com.test.good_application_1.2.3"), /* params, the same */
                                   NULL);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", last_observer);
+    /* Make sure we run our observer */
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID(ubuntu::app_launch::AppID::Package::from_raw("com.test.good"),
+                                                   ubuntu::app_launch::AppID::AppName::from_raw("application"),
+                                                   ubuntu::app_launch::AppID::Version::from_raw("1.2.3")),
+                         manager.lock()->lastStartedApp);
+
+    /* Make sure we return */
     EXPECT_EVENTUALLY_EQ(1, starting_count);
 
-    EXPECT_TRUE(ubuntu_app_launch_observer_delete_app_starting(starting_observer, &last_observer));
-
     g_dbus_connection_remove_filter(session, filter);
     g_object_unref(session);
 }
@@ -947,8 +983,10 @@
     auto app = ubuntu::app_launch::Application::create(appid, registry);
     app->launch();
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
 }
 
 GDBusMessage* filter_func_good(GDBusConnection* conn, GDBusMessage* message, gboolean incomming, gpointer user_data)
@@ -982,8 +1020,10 @@
 
     app->launch(uris);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
 
     g_dbus_connection_remove_filter(session, filter);
 
@@ -1015,8 +1055,10 @@
 
     app->launch(uris);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
 }
 
 TEST_F(LibUAL, UnityTimeoutTest)
@@ -1028,8 +1070,10 @@
 
     app->launch();
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
 }
 
 TEST_F(LibUAL, UnityTimeoutUriTest)
@@ -1043,8 +1087,10 @@
 
     app->launch(uris);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
 }
 
 GDBusMessage* filter_respawn(GDBusConnection* conn, GDBusMessage* message, gboolean incomming, gpointer user_data)
@@ -1077,8 +1123,10 @@
     g_debug("Start call time: %d ms", (end - start) / 1000);
     EXPECT_LT(end - start, 2000 * 1000);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastFocusedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"),
+                         this->manager.lock()->lastResumedApp);
 
     g_dbus_connection_remove_filter(session, filter);
     g_object_unref(session);
@@ -1138,23 +1186,21 @@
     g_variant_unref(env);
 }
 
-static void failed_observer(const gchar* appid, UbuntuAppLaunchAppFailed reason, gpointer user_data)
-{
-    if (reason == UBUNTU_APP_LAUNCH_APP_FAILED_CRASH)
-    {
-        std::string* last = static_cast<std::string*>(user_data);
-        *last = appid;
-    }
-    return;
-}
-
 TEST_F(LibUAL, FailingObserver)
 {
-    std::string last_observer;
+    ubuntu::app_launch::AppID lastFailedApp;
+    ubuntu::app_launch::Registry::FailureType lastFailedType;
+
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&lastFailedApp, &lastFailedType](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                          std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                          ubuntu::app_launch::Registry::FailureType type) {
+            lastFailedApp = app->appId();
+            lastFailedType = type;
+        });
+
     GDBusConnection* session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
 
-    EXPECT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
     g_dbus_connection_emit_signal(
         session, NULL,                                                     /* destination */
         "/",                                                               /* path */
@@ -1163,9 +1209,10 @@
         g_variant_new("(ss)", "com.test.good_application_1.2.3", "crash"), /* params, the same */
         NULL);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", last_observer);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"), lastFailedApp);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::Registry::FailureType::CRASH, lastFailedType);
 
-    last_observer.clear();
+    lastFailedApp = ubuntu::app_launch::AppID();
 
     g_dbus_connection_emit_signal(
         session, NULL,                                                        /* destination */
@@ -1175,9 +1222,9 @@
         g_variant_new("(ss)", "com.test.good_application_1.2.3", "blahblah"), /* params, the same */
         NULL);
 
-    EXPECT_EVENTUALLY_EQ("com.test.good_application_1.2.3", last_observer);
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::AppID::parse("com.test.good_application_1.2.3"), lastFailedApp);
 
-    last_observer.clear();
+    lastFailedApp = ubuntu::app_launch::AppID();
 
     g_dbus_connection_emit_signal(
         session, NULL,                                                             /* destination */
@@ -1187,9 +1234,7 @@
         g_variant_new("(ss)", "com.test.good_application_1.2.3", "start-failure"), /* params, the same */
         NULL);
 
-    EXPECT_EVENTUALLY_EQ(true, last_observer.empty());
-
-    EXPECT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+    EXPECT_EVENTUALLY_EQ(ubuntu::app_launch::Registry::FailureType::START_FAILURE, lastFailedType);
 
     g_object_unref(session);
 }
 
=== modified file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	2016-06-18 18:24:27 +0000
+++ tools/CMakeLists.txt	2016-11-07 20:56:13 +0000
@@ -39,7 +39,7 @@
 # ubuntu-app-launch
 ########################
 
-add_executable(ubuntu-app-launch ubuntu-app-launch.c)
+add_executable(ubuntu-app-launch ubuntu-app-launch.cpp)
 set_target_properties(ubuntu-app-launch PROPERTIES OUTPUT_NAME "ubuntu-app-launch")
 target_link_libraries(ubuntu-app-launch ubuntu-launcher)
 install(TARGETS ubuntu-app-launch RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}")
@@ -48,7 +48,7 @@
 # ubuntu-app-watch
 ########################
 
-add_executable(ubuntu-app-watch ubuntu-app-watch.c)
+add_executable(ubuntu-app-watch ubuntu-app-watch.cpp)
 set_target_properties(ubuntu-app-watch PROPERTIES OUTPUT_NAME "ubuntu-app-watch")
 target_link_libraries(ubuntu-app-watch ubuntu-launcher)
 install(TARGETS ubuntu-app-watch RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}")
@@ -116,3 +116,22 @@
 target_link_libraries(ubuntu-app-usage ubuntu-launcher)
 install(TARGETS ubuntu-app-usage RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}")
 
+########################
+# Formatting
+########################
+
+add_custom_target(format-tools
+	COMMAND clang-format -i -style=file
+    ubuntu-app-info.cpp
+    ubuntu-app-launch-appids.cpp
+    ubuntu-app-launch.cpp
+    ubuntu-app-list.cpp
+    ubuntu-app-list-pids.cpp
+    ubuntu-app-pid.cpp
+    ubuntu-app-stop.cpp
+    ubuntu-app-triplet.cpp
+    ubuntu-app-watch.cpp
+    ubuntu-helper-list.cpp
+    ubuntu-helper-start.cpp
+    ubuntu-helper-stop.cpp
+)
 
=== modified file 'tools/ubuntu-app-info.cpp'
--- tools/ubuntu-app-info.cpp	2016-05-04 14:09:10 +0000
+++ tools/ubuntu-app-info.cpp	2016-11-07 20:56:13 +0000
@@ -17,34 +17,40 @@
  *     Ted Gould <[e-mail]>
  */
 
-#include <iostream>
 #include "libubuntu-app-launch/application.h"
 #include "libubuntu-app-launch/registry.h"
+#include <iostream>
 
-int main(int argc, char* argv[])
+int main(int argc, char *argv[])
 {
-    if (argc != 2) {
+    if (argc != 2)
+    {
         std::cerr << "Usage: " << argv[0] << " (appid)" << std::endl;
         exit(1);
     }
 
     auto appid = ubuntu::app_launch::AppID::find(argv[1]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find app for appid: " << argv[1] << std::endl;
         return 1;
     }
 
     std::shared_ptr<ubuntu::app_launch::Application> app;
-    try {
+    try
+    {
         app = ubuntu::app_launch::Application::create(appid, ubuntu::app_launch::Registry::getDefault());
         if (!app)
             throw std::runtime_error("Application object is nullptr");
-    } catch (std::runtime_error &e) {
+    }
+    catch (std::runtime_error &e)
+    {
         std::cerr << "Unable to find application for AppID: " << argv[1] << std::endl;
         exit(1);
     }
 
-    try {
+    try
+    {
         auto info = app->info();
 
         std::cout << "Name:             " << info->name().value() << std::endl;
@@ -64,8 +70,11 @@
         std::cout << "  Inv Landscape:  " << info->supportedOrientations().invertedLandscape << std::endl;
         std::cout << "Rotates:          " << info->rotatesWindowContents().value() << std::endl;
         std::cout << "Ubuntu Lifecycle: " << info->supportsUbuntuLifecycle().value() << std::endl;
-    } catch (std::runtime_error &e) {
-        std::cerr << "Unable to parse Application info for application '" << std::string(appid) << "': " << e.what() << std::endl;
+    }
+    catch (std::runtime_error &e)
+    {
+        std::cerr << "Unable to parse Application info for application '" << std::string(appid) << "': " << e.what()
+                  << std::endl;
         exit(1);
     }
 
 
=== renamed file 'tools/ubuntu-app-launch.c' => 'tools/ubuntu-app-launch.cpp'
--- tools/ubuntu-app-launch.c	2016-02-08 19:03:31 +0000
+++ tools/ubuntu-app-launch.cpp	2016-11-07 20:56:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 Canonical Ltd.
+ * Copyright © 2016 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
@@ -17,71 +17,59 @@
  *     Ted Gould <[e-mail]>
  */
 
-#include <glib.h>
-#include "libubuntu-app-launch/ubuntu-app-launch.h"
-
-const gchar * global_appid = NULL;
-int retval = 0;
-
-static void
-good_observer (const gchar * appid, gpointer user_data)
-{
-	if (g_strcmp0(appid, global_appid) != 0) {
-		return;
-	}
-
-	g_debug("Application '%s' running", appid);
-	g_main_loop_quit((GMainLoop *)user_data);
-}
-
-static void
-bad_observer (const gchar * appid, UbuntuAppLaunchAppFailed failure_type, gpointer user_data)
-{
-	if (g_strcmp0(appid, global_appid) != 0) {
-		return;
-	}
-
-	g_debug("Application '%s' failed: %s", appid, failure_type == UBUNTU_APP_LAUNCH_APP_FAILED_CRASH ? "crash" : "startup failure");
-	retval = -1;
-	g_main_loop_quit((GMainLoop *)user_data);
-}
-
-int
-main (int argc, gchar * argv[]) {
-	if (argc < 2) {
-		g_printerr("Usage: %s <app id> [uris]\n", argv[0]);
-		return 1;
-	}
-
-	global_appid = argv[1];
-	GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-
-	gchar ** uris = NULL;
-	if (argc > 2) {
-		int i;
-
-		uris = g_new0(gchar *, argc - 1);
-
-		for (i = 2; i < argc; i++) {
-			uris[i - 2] = argv[i];
-		}
-	}
-
-	ubuntu_app_launch_observer_add_app_started(good_observer, mainloop);
-	ubuntu_app_launch_observer_add_app_focus(good_observer, mainloop);
-
-	ubuntu_app_launch_observer_add_app_failed(bad_observer, mainloop);
-
-	ubuntu_app_launch_start_application(global_appid, (const gchar * const *)uris);
-
-	g_main_loop_run(mainloop);
-
-	ubuntu_app_launch_observer_delete_app_started(good_observer, mainloop);
-	ubuntu_app_launch_observer_delete_app_focus(good_observer, mainloop);
-	ubuntu_app_launch_observer_delete_app_failed(bad_observer, mainloop);
-
-	g_main_loop_unref(mainloop);
-	g_free(uris);
-
-	return retval;
+#include "libubuntu-app-launch/application.h"
+#include "libubuntu-app-launch/registry.h"
+#include <csignal>
+#include <future>
+#include <iostream>
+
+ubuntu::app_launch::AppID global_appid;
+std::promise<int> retval;
+
+int main(int argc, char* argv[])
+{
+    if (argc < 2)
+    {
+        std::cerr << "Usage: " << argv[0] << " <app id> [uris]" << std::endl;
+        return 1;
+    }
+
+    global_appid = ubuntu::app_launch::AppID::find(argv[1]);
+
+    std::vector<ubuntu::app_launch::Application::URL> urls;
+    for (int i = 2; i < argc; i++)
+    {
+        urls.push_back(ubuntu::app_launch::Application::URL::from_raw(argv[i]));
+    }
+
+    ubuntu::app_launch::Registry::appStarted().connect(
+        [](std::shared_ptr<ubuntu::app_launch::Application> app,
+           std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+            if (app->appId() != global_appid)
+            {
+                return;
+            }
+
+            std::cout << "Started: " << (std::string)app->appId() << std::endl;
+            retval.set_value(EXIT_SUCCESS);
+        });
+
+    ubuntu::app_launch::Registry::appFailed().connect(
+        [](std::shared_ptr<ubuntu::app_launch::Application> app,
+           std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+           ubuntu::app_launch::Registry::FailureType type) {
+            if (app->appId() != global_appid)
+            {
+                return;
+            }
+
+            std::cout << "Failed:  " << (std::string)app->appId() << std::endl;
+            retval.set_value(EXIT_FAILURE);
+        });
+
+    auto app = ubuntu::app_launch::Application::create(global_appid, ubuntu::app_launch::Registry::getDefault());
+    app->launch(urls);
+
+    std::signal(SIGTERM, [](int signal) -> void { retval.set_value(EXIT_SUCCESS); });
+    return retval.get_future().get();
 }
 
=== modified file 'tools/ubuntu-app-list-pids.cpp'
--- tools/ubuntu-app-list-pids.cpp	2016-05-03 01:46:27 +0000
+++ tools/ubuntu-app-list-pids.cpp	2016-11-07 20:56:13 +0000
@@ -30,12 +30,14 @@
     }
 
     auto appid = ubuntu::app_launch::AppID::find(argv[1]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find app for appid: " << argv[1] << std::endl;
         return 1;
     }
 
-    try {
+    try
+    {
         auto app = ubuntu::app_launch::Application::create(appid, ubuntu::app_launch::Registry::getDefault());
 
         for (auto instance : app->instances())
@@ -45,7 +47,9 @@
                 std::cout << pid << std::endl;
             }
         }
-    } catch (std::runtime_error &e) {
+    }
+    catch (std::runtime_error& e)
+    {
         std::cerr << "Unable to find application for '" << std::string(appid) << "': " << e.what() << std::endl;
         return 1;
     }
 
=== modified file 'tools/ubuntu-app-list.cpp'
--- tools/ubuntu-app-list.cpp	2016-02-09 21:12:54 +0000
+++ tools/ubuntu-app-list.cpp	2016-11-07 20:56:13 +0000
@@ -17,8 +17,8 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "libubuntu-app-launch/registry.h"
 #include <iostream>
-#include "libubuntu-app-launch/registry.h"
 
 int main(int argc, char* argv[])
 {
 
=== modified file 'tools/ubuntu-app-pid.cpp'
--- tools/ubuntu-app-pid.cpp	2016-05-03 01:46:51 +0000
+++ tools/ubuntu-app-pid.cpp	2016-11-07 20:56:13 +0000
@@ -18,8 +18,8 @@
  */
 
 #include <iostream>
+#include <libubuntu-app-launch/application.h>
 #include <libubuntu-app-launch/registry.h>
-#include <libubuntu-app-launch/application.h>
 
 int main(int argc, char* argv[])
 {
@@ -31,12 +31,14 @@
     }
 
     auto appid = ubuntu::app_launch::AppID::find(argv[1]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find app for appid: " << argv[1] << std::endl;
         return 1;
     }
 
-    try {
+    try
+    {
         auto app = ubuntu::app_launch::Application::create(appid, ubuntu::app_launch::Registry::getDefault());
         auto pid = app->instances()[0]->primaryPid();
 
@@ -47,7 +49,9 @@
 
         std::cout << pid << std::endl;
         return 0;
-    } catch (std::runtime_error &e) {
+    }
+    catch (std::runtime_error& e)
+    {
         std::cerr << "Unable to find application for '" << std::string(appid) << "': " << e.what() << std::endl;
         return 1;
     }
 
=== modified file 'tools/ubuntu-app-stop.cpp'
--- tools/ubuntu-app-stop.cpp	2016-05-03 01:46:27 +0000
+++ tools/ubuntu-app-stop.cpp	2016-11-07 20:56:13 +0000
@@ -30,19 +30,23 @@
     }
 
     auto appid = ubuntu::app_launch::AppID::find(argv[1]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find app for appid: " << argv[1] << std::endl;
         return 1;
     }
 
-    try {
+    try
+    {
         auto app = ubuntu::app_launch::Application::create(appid, ubuntu::app_launch::Registry::getDefault());
 
         for (auto instance : app->instances())
         {
             instance->stop();
         }
-    } catch (std::runtime_error &e) {
+    }
+    catch (std::runtime_error& e)
+    {
         std::cerr << "Unable to find application for '" << std::string(appid) << "': " << e.what() << std::endl;
         return 1;
     }
 
=== modified file 'tools/ubuntu-app-triplet.cpp'
--- tools/ubuntu-app-triplet.cpp	2016-02-09 21:12:54 +0000
+++ tools/ubuntu-app-triplet.cpp	2016-11-07 20:56:13 +0000
@@ -17,8 +17,8 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "libubuntu-app-launch/application.h"
 #include <iostream>
-#include "libubuntu-app-launch/application.h"
 
 int main(int argc, char* argv[])
 {
 
=== renamed file 'tools/ubuntu-app-watch.c' => 'tools/ubuntu-app-watch.cpp'
--- tools/ubuntu-app-watch.c	2016-02-08 19:03:31 +0000
+++ tools/ubuntu-app-watch.cpp	2016-11-07 20:56:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 Canonical Ltd.
+ * Copyright © 2015 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
@@ -17,91 +17,64 @@
  *     Ted Gould <[e-mail]>
  */
 
-#include "libubuntu-app-launch/ubuntu-app-launch.h"
-
-void
-starting (const gchar * appid, gpointer user_data)
-{
-	g_print("Starting %s\n", appid);
-	return;
-}
-
-void
-started (const gchar * appid, gpointer user_data)
-{
-	g_print("Started  %s\n", appid);
-	return;
-}
-
-void
-stopped (const gchar * appid, gpointer user_data)
-{
-	g_print("Stop     %s\n", appid);
-	return;
-}
-
-void
-resumed (const gchar * appid, GPid * pids, gpointer user_data)
-{
-	g_print("Resumed  %s\n", appid);
-	return;
-}
-
-void
-paused (const gchar * appid, GPid * pids, gpointer user_data)
-{
-	g_print("Paused   %s\n", appid);
-	return;
-}
-
-void
-focus (const gchar * appid, gpointer user_data)
-{
-	g_print("Focus    %s\n", appid);
-	return;
-}
-
-void
-fail (const gchar * appid, UbuntuAppLaunchAppFailed failhow, gpointer user_data)
-{
-	const gchar * failstr = "unknown";
-	switch (failhow) {
-		case UBUNTU_APP_LAUNCH_APP_FAILED_CRASH:
-			failstr = "crashed";
-			break;
-		case UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE:
-			failstr = "startup";
-			break;
-	}
-
-	g_print("Fail     %s (%s)\n", appid, failstr);
-	return;
-}
-
-
-int
-main (int argc, gchar * argv[])
-{
-	ubuntu_app_launch_observer_add_app_starting(starting, NULL);
-	ubuntu_app_launch_observer_add_app_started(started, NULL);
-	ubuntu_app_launch_observer_add_app_stop(stopped, NULL);
-	ubuntu_app_launch_observer_add_app_focus(focus, NULL);
-	ubuntu_app_launch_observer_add_app_resumed(resumed, NULL);
-	ubuntu_app_launch_observer_add_app_paused(paused, NULL);
-	ubuntu_app_launch_observer_add_app_failed(fail, NULL);
-
-	GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-	g_main_loop_run(mainloop);
-
-	ubuntu_app_launch_observer_delete_app_starting(starting, NULL);
-	ubuntu_app_launch_observer_delete_app_started(started, NULL);
-	ubuntu_app_launch_observer_delete_app_stop(stopped, NULL);
-	ubuntu_app_launch_observer_delete_app_focus(focus, NULL);
-	ubuntu_app_launch_observer_delete_app_resumed(resumed, NULL);
-	ubuntu_app_launch_observer_delete_app_paused(paused, NULL);
-	ubuntu_app_launch_observer_delete_app_failed(fail, NULL);
-
-	g_main_loop_unref(mainloop);
-
-	return 0;
+#include "libubuntu-app-launch/registry.h"
+#include <csignal>
+#include <future>
+
+std::promise<int> retval;
+
+int main(int argc, char *argv[])
+{
+    ubuntu::app_launch::Registry registry;
+
+    registry.appStarted().connect([](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+        std::cout << "Started: " << (std::string)app->appId() << std::endl;
+    });
+    registry.appStopped().connect([](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+        std::cout << "Stopped: " << (std::string)app->appId() << std::endl;
+    });
+    registry.appPaused().connect([](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                    std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                    std::vector<pid_t> &pids) {
+        std::cout << "Paused:  " << (std::string)app->appId() << " (";
+
+        for (auto pid : pids)
+        {
+            std::cout << std::to_string(pid) << " ";
+        }
+
+        std::cout << ")" << std::endl;
+    });
+    registry.appResumed().connect([](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                     std::vector<pid_t> &pids) {
+        std::cout << "Resumed: " << (std::string)app->appId() << " (";
+
+        for (auto pid : pids)
+        {
+            std::cout << std::to_string(pid) << " ";
+        }
+
+        std::cout << ")" << std::endl;
+    });
+    registry.appFailed().connect([](std::shared_ptr<ubuntu::app_launch::Application> app,
+                                    std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                    ubuntu::app_launch::Registry::FailureType type) {
+        std::cout << "Failed:  " << (std::string)app->appId();
+        switch (type)
+        {
+            case ubuntu::app_launch::Registry::FailureType::CRASH:
+                std::cout << " (crash)";
+                break;
+            case ubuntu::app_launch::Registry::FailureType::START_FAILURE:
+                std::cout << " (start failure)";
+                break;
+        }
+        std::cout << std::endl;
+    });
+
+    std::signal(SIGTERM, [](int signal) -> void { retval.set_value(EXIT_SUCCESS); });
+    return retval.get_future().get();
 }
 
=== modified file 'tools/ubuntu-helper-list.cpp'
--- tools/ubuntu-helper-list.cpp	2016-02-09 21:12:54 +0000
+++ tools/ubuntu-helper-list.cpp	2016-11-07 20:56:13 +0000
@@ -17,8 +17,8 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "libubuntu-app-launch/registry.h"
 #include <iostream>
-#include "libubuntu-app-launch/registry.h"
 
 int main(int argc, char* argv[])
 {
 
=== modified file 'tools/ubuntu-helper-start.cpp'
--- tools/ubuntu-helper-start.cpp	2016-05-03 01:46:27 +0000
+++ tools/ubuntu-helper-start.cpp	2016-11-07 20:56:13 +0000
@@ -17,9 +17,9 @@
  *     Ted Gould <[e-mail]>
  */
 
-#include <iostream>
 #include "libubuntu-app-launch/helper.h"
 #include "libubuntu-app-launch/registry.h"
+#include <iostream>
 
 int main(int argc, char* argv[])
 {
@@ -31,20 +31,25 @@
 
     auto type = ubuntu::app_launch::Helper::Type::from_raw(argv[1]);
     auto appid = ubuntu::app_launch::AppID::find(argv[2]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find helper for appid: " << argv[1] << std::endl;
         return 1;
     }
 
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
 
-    try {
+    try
+    {
         auto helper = ubuntu::app_launch::Helper::create(type, appid, registry);
 
         helper->launch();
         return 0;
-    } catch (std::runtime_error &e) {
-        std::cerr << "Unable to find helper for '" << std::string(appid) << "' type '" << type.value() << "': " << e.what() << std::endl;
+    }
+    catch (std::runtime_error& e)
+    {
+        std::cerr << "Unable to find helper for '" << std::string(appid) << "' type '" << type.value()
+                  << "': " << e.what() << std::endl;
         return 1;
     }
 }
 
=== modified file 'tools/ubuntu-helper-stop.cpp'
--- tools/ubuntu-helper-stop.cpp	2016-05-03 01:46:27 +0000
+++ tools/ubuntu-helper-stop.cpp	2016-11-07 20:56:13 +0000
@@ -17,9 +17,9 @@
  *     Ted Gould <[e-mail]>
  */
 
-#include <iostream>
 #include "libubuntu-app-launch/helper.h"
 #include "libubuntu-app-launch/registry.h"
+#include <iostream>
 
 int main(int argc, char* argv[])
 {
@@ -31,14 +31,16 @@
 
     auto type = ubuntu::app_launch::Helper::Type::from_raw(argv[1]);
     auto appid = ubuntu::app_launch::AppID::find(argv[2]);
-    if (appid.empty()) {
+    if (appid.empty())
+    {
         std::cerr << "Unable to find helper for appid: " << argv[1] << std::endl;
         return 1;
     }
 
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
 
-    try {
+    try
+    {
         auto helper = ubuntu::app_launch::Helper::create(type, appid, registry);
 
         for (auto instance : helper->instances())
@@ -47,8 +49,11 @@
         }
 
         return 0;
-    } catch (std::runtime_error &e) {
-        std::cerr << "Unable to find helper for '" << std::string(appid) << "' type '" << type.value() << "': " << e.what() << std::endl;
+    }
+    catch (std::runtime_error& e)
+    {
+        std::cerr << "Unable to find helper for '" << std::string(appid) << "' type '" << type.value()
+                  << "': " << e.what() << std::endl;
         return 1;
     }
 }