Merge lp:~mterry/ubuntu-app-launch/warn-on-xapp into lp:ubuntu-app-launch/15.10

[Michael Terry]

Allow Unity to prevent an app from starting and give it as long as it wants to figure that out.

Allow Unity to prevent an app from starting and give it as long as it wants to figure that out.

This branch gives Unity the option to prevent an app from launching by blocking on its answer before actually starting the app and then acting on that answer.

Related branches:
 https://code.launchpad.net/~mterry/unity-api/warn-on-xapp/+merge/277922
 https://code.launchpad.net/~mterry/qtmir/warn-on-xapp/+merge/279172
 https://code.launchpad.net/~mterry/unity8/warn-on-xapp/+merge/277915

== The existing design ==

The current code goes through pains to avoid any knowledge of Unity (despite using the name Unity in several signals). It doesn't connect to it on the bus. And it doesn't restrict who can answer its "I am starting an app" signal.

I'm not sure why it does this, but it does. So the way it communicates is via broadcast signals on the bus. Which gets answered by "someone" (presumably Unity). If there are multiple signal observers on the bus, we continue launching the app as soon as we hear the first response.

It also waits 1s for an answer; if no answer is received, it just launches the app anyway. The signal is more of a courtesy to Unity than a requirement. So if Unity isn't running, exits before it can respond, or is taking too long, UAL just continues.

== New design ==

The new paradigm is that Unity is an approver of which apps can launch. The proximate reason for this MP is that we want to be able to stop legacy apps from launching when not in Desktop mode. But I could imagine other scenarios (parental controls on some apps, or admin privileges needed for some apps, etc). [1]

I also wanted to allow Unity to take as long as it wanted to decide. Because maybe it is taking user input (authenticating as parent maybe) or in the case of a legacy app on the phone, waiting for user to either cancel the app launch or dock the phone (in which case we'd like to continue the app launch).

If Unity is not running, I've assumed we don't want the app to launch (which is a behavior change).

== Changes ==

- So we want to change the API for observers of the "starting" signal to allow for providing an "approved or not" answer. And we want to make it easy to answer in an async manner. Unfortunately, the current API has no state (no objects on which the API acts) to match up callbacks to their answers. So rather than redo the API, I've just added a new API call that app-starting-observers can use to answer any app-starting message: ubuntu_app_launch_observer_finish_app_starting(). It just broadcasts the answer on the bus. If that new method is not called, the app will never finish launching. The only current user of this API should be unity8, for which I have a related branch to use this new API.

- We want to know if Unity is even running (if not, we should reject the app). So I've kept the immediate signal response UnityStartingSignal, so that UAL knows someone is listening and handling the request. If it doesn't hear that signal within 5s, we reject the app. (I think it would be nicer to call com.canonical.Unity.RequestAppStart or similar, which would mean that only Unity could handle the request, would immediately tell us if Unity is running, and would give us a nice error instead of silence on the bus if something is wrong. But I didn't want to change the design of UAL that much, so I've kept the signal dance.)

- As noted above, I've bumped the timeout from 1s to 5s. This is because now we reject by default if the timeout happens, so it's more important that we give unity8 time. And secondly, we're adding an async API, so increasing the potential blocking time shouldn't be as much of a burden.

- We only support listening to the first responder we hear on the bus. This would be easy to extend to support listening to all responders we hear and waiting for all of them to weigh in. But I didn't need that feature yet, so I didn't write it.

- Since we now wait as long as Unity wants, we have to be sensitive to Unity quitting on us. So once we hear UnityStartingSignal, we also listen for NameOwnerChanges on the bus.

- Eventually, Unity gets back to us with a UnityStartingApproved signal that tells us to continue or not.

- Consolidating the handshake logic out of click-exec.c and desktop-exec.c has the side effect of fixing a bug where task_setup failed but we already emitted a UnityStartingBroadcast. And we had no way to cancel the handshake. So Unity would think an app was starting even though it wasn't. Now all the handshaking happens right in a row, without the ability to fail due to desktop parsing or similar.

- I've added an async version of ubuntu_app_launch_start_application so that callers don't have to block on this whole process (even without this branch, there was blocking occurring, waiting up to 5s on signals -- this method should definitively have existed before anyway).

== Footnotes ==

[1] ubuntu_app_launch_start_application is only for unconfined apps, right? Specifically, Touch apps or scopes can't start something via upstart directly themselves, bypassing the above scheme? I *believe* they always have to go the URLDispatcher route. Otherwise, this paradigm wouldn't really work for parental controls.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:215
http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-ci/21/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-amd64-ci/21/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-armhf-ci/21/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-app-launch-wily-i386-ci/21/console

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

review: Needs Fixing (continuous-integration)

[lp:~mterry/ubuntu-app-launch/warn-on-xapp]

216. By Michael Terry on 2015-12-02

Fix tests to still use old smaller timeout for convenience

Unmerged revisions

216. By Michael Terry on 2015-12-02

Fix tests to still use old smaller timeout for convenience

215. By Michael Terry on 2015-12-02

Bump timeout to 5s

214. By Michael Terry on 2015-11-25

Add async versions of start_application calls

213. By Michael Terry on 2015-11-24

fix tabs and revert some unnecessary wording changes

212. By Michael Terry on 2015-11-24

Wait for unity to get back to us

211. By Michael Terry on 2015-11-23

Allow server-side of handshake to be async by adding ubuntu_app_launch_observer_finish_app_starting

210. By Michael Terry on 2015-11-23

Add 'approved' bool parameter to UnityStartingSignal return signal, so that unity could prevent an app from opening

209. By Michael Terry on 2015-11-23

Fix ftbfs

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-08-11 02:45:49 +0000
+++ CMakeLists.txt	2015-12-02 17:21:30 +0000
@@ -90,6 +90,10 @@
 add_library(helpers STATIC helpers.c helpers-shared.c libubuntu-app-launch/recoverable-problem.c)
 target_link_libraries(helpers ${GIO2_LIBRARIES} ${JSONGLIB_LIBRARIES} ${CLICK_LIBRARIES})
 
+add_library(helpers-test STATIC helpers.c helpers-shared.c libubuntu-app-launch/recoverable-problem.c)
+set_target_properties(helpers-test PROPERTIES COMPILE_DEFINITIONS "UAL_TEST_MODE")
+target_link_libraries(helpers-test ${GIO2_LIBRARIES} ${JSONGLIB_LIBRARIES} ${CLICK_LIBRARIES})
+
 ####################
 # desktop-hook
 ####################

=== modified file 'data/com.canonical.UbuntuAppLaunch.xml'
--- data/com.canonical.UbuntuAppLaunch.xml	2015-03-04 14:26:35 +0000
+++ data/com.canonical.UbuntuAppLaunch.xml	2015-12-02 17:21:30 +0000
@@ -16,6 +16,10 @@
 		<signal name="UnityStartingSignal">
 			<arg type="s" name="appid" />
 		</signal>
+		<signal name="UnityStartingApproved">
+			<arg type="s" name="appid" />
+			<arg type="b" name="approved" />
+		</signal>
 		<signal name="ApplicationFailed">
 			<arg type="s" name="appid" />
 			<arg type="s" name="stage" />

=== modified file 'debian/changelog'
--- debian/changelog	2015-08-17 21:38:34 +0000
+++ debian/changelog	2015-12-02 17:21:30 +0000
@@ -1,3 +1,11 @@
+ubuntu-app-launch (0.6) xenial; urgency=medium
+
+  * Bump version because the expectations for callers of
+    ubuntu_app_launch_observer_add_app_starting has changed (to expect
+    a further call to ubuntu_app_launch_observer_finish_app_starting)
+
+ -- Michael Terry <[e-mail]>  Mon, 23 Nov 2015 16:25:15 -0500
+
 ubuntu-app-launch (0.5+15.10.20150817-0ubuntu1) wily; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'debian/libubuntu-app-launch2.symbols'
--- debian/libubuntu-app-launch2.symbols	2015-08-17 21:38:34 +0000
+++ debian/libubuntu-app-launch2.symbols	2015-12-02 17:21:30 +0000
@@ -27,10 +27,13 @@
  ubuntu_app_launch_observer_delete_app_stop@Base 0.4
  ubuntu_app_launch_observer_delete_helper_started@Base 0.4
  ubuntu_app_launch_observer_delete_helper_stop@Base 0.4
+ ubuntu_app_launch_observer_finish_app_starting@Base 0.6
  ubuntu_app_launch_pause_application@Base 0.4+14.10.20140915.3
  ubuntu_app_launch_pid_in_app_id@Base 0.4
  ubuntu_app_launch_resume_application@Base 0.4+14.10.20140915.3
  ubuntu_app_launch_start_application@Base 0.4
+ ubuntu_app_launch_start_application_async@Base 0.6
+ ubuntu_app_launch_start_application_async_test@Base 0.6
  ubuntu_app_launch_start_application_test@Base 0.4
  ubuntu_app_launch_start_helper@Base 0.4
  ubuntu_app_launch_start_multiple_helper@Base 0.4

=== modified file 'helpers.c'
--- helpers.c	2014-08-08 19:50:53 +0000
+++ helpers.c	2015-12-02 17:21:30 +0000
@@ -473,42 +473,146 @@
 	return;
 }
 
-static void
-unity_signal_cb (GDBusConnection * con, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	GMainLoop * mainloop = (GMainLoop *)user_data;
-	g_main_loop_quit(mainloop);
-}
-
 struct _handshake_t {
 	GDBusConnection * con;
 	GMainLoop * mainloop;
 	guint signal_subscribe;
+	guint approved_subscribe;
+	guint name_subscribe;
 	guint timeout;
+	gboolean received;
+	gchar *receiver;
+	HandshakeCallback callback;
+	gpointer user_data;
+	GDestroyNotify user_data_free;
 };
 
+static void
+handshake_free(handshake_t * handshake)
+{
+	if (handshake->timeout != 0) {
+		g_source_remove(handshake->timeout);
+	}
+	if (handshake->mainloop != NULL) {
+		g_main_loop_unref(handshake->mainloop);
+	}
+	if (handshake->signal_subscribe != 0) {
+		g_dbus_connection_signal_unsubscribe(handshake->con, handshake->signal_subscribe);
+	}
+	if (handshake->approved_subscribe != 0) {
+		g_dbus_connection_signal_unsubscribe(handshake->con, handshake->approved_subscribe);
+	}
+	if (handshake->name_subscribe != 0) {
+		g_dbus_connection_signal_unsubscribe(handshake->con, handshake->name_subscribe);
+	}
+	g_free(handshake->receiver);
+	g_object_unref(handshake->con);
+
+	if (handshake->user_data_free != NULL && handshake->user_data != NULL) {
+		handshake->user_data_free(handshake->user_data);
+	}
+
+	g_free(handshake);
+}
+
+static void
+handshake_stop(handshake_t * handshake, gboolean approved)
+{
+	if (approved) {
+		handshake->callback(handshake->user_data);
+	}
+
+	if (handshake->mainloop != NULL) {
+		g_main_loop_quit(handshake->mainloop);
+	}
+
+	handshake_free(handshake);
+}
+
+static void
+unity_name_cb (GDBusConnection * con, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+{
+	handshake_t * handshake = (handshake_t *)user_data;
+
+	if (g_variant_check_format_string(params, "(sss)", FALSE)) {
+		const gchar *new_name = NULL;
+		g_variant_get(params, "(ss&s)", NULL, NULL, &new_name);
+
+		if (new_name == NULL || new_name[0] == 0) {
+			// The process we were talking to exited!  Let's stop waiting.
+			handshake_stop(handshake, FALSE);
+		}
+	}
+}
+
+static void
+unity_signal_cb (GDBusConnection * con, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+{
+	handshake_t * handshake = (handshake_t *)user_data;
+
+	if (!handshake->received) { // only allow the first responder
+		handshake->receiver = g_strdup(sender);
+		handshake->received = TRUE;
+
+		handshake->name_subscribe = g_dbus_connection_signal_subscribe(handshake->con,
+#ifdef UAL_TEST_MODE
+			NULL, /* accept from any sender, making it easier for tests to fake this signal */
+#else
+			"org.freedesktop.DBus", /* sender */
+#endif
+			"org.freedesktop.DBus", /* interface */
+			"NameOwnerChanged", /* signal */
+			"/org/freedesktop/DBus", /* path */
+			sender, /* arg0 */
+			G_DBUS_SIGNAL_FLAGS_NONE,
+			unity_name_cb, handshake,
+			NULL); /* user data destroy */
+	}
+}
+
+static void
+unity_approved_cb (GDBusConnection * con, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+{
+	handshake_t * handshake = (handshake_t *)user_data;
+
+	if (!handshake->received || g_strcmp0(sender, handshake->receiver) != 0) {
+		return;
+	}
+
+	gboolean approved = FALSE;
+	if (g_variant_check_format_string(params, "(sb)", FALSE)) {
+		g_variant_get(params, "(sb)", NULL, &approved);
+	}
+
+	handshake_stop(handshake, approved);
+}
+
 static gboolean
 unity_too_slow_cb (gpointer user_data)
 {
 	handshake_t * handshake = (handshake_t *)user_data;
-	g_main_loop_quit(handshake->mainloop);
 	handshake->timeout = 0;
+	if (!handshake->received) {
+		handshake_stop(handshake, FALSE);
+	}
 	return G_SOURCE_REMOVE;
 }
 
 handshake_t *
-starting_handshake_start (const gchar *   app_id)
+starting_handshake_start (const gchar * app_id, HandshakeCallback callback, gpointer user_data, GDestroyNotify user_data_free)
 {
 	GError * error = NULL;
 	handshake_t * handshake = g_new0(handshake_t, 1);
 
-	handshake->mainloop = g_main_loop_new(NULL, FALSE);
+	handshake->callback = callback;
+	handshake->user_data = user_data;
+	handshake->user_data_free = user_data_free;
+
 	handshake->con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
-
 	if (error != NULL) {
 		g_critical("Unable to connect to session bus: %s", error->message);
 		g_error_free(error);
-		g_free(handshake);
+		handshake_free(handshake);
 		return NULL;
 	}
 
@@ -520,7 +624,17 @@
 		"/", /* path */
 		app_id, /* arg0 */
 		G_DBUS_SIGNAL_FLAGS_NONE,
-		unity_signal_cb, handshake->mainloop,
+		unity_signal_cb, handshake,
+		NULL); /* user data destroy */
+
+	handshake->approved_subscribe = g_dbus_connection_signal_subscribe(handshake->con,
+		NULL, /* sender */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		"/", /* path */
+		app_id, /* arg0 */
+		G_DBUS_SIGNAL_FLAGS_NONE,
+		unity_approved_cb, handshake,
 		NULL); /* user data destroy */
 
 	/* Send unfreeze to to Unity */
@@ -532,8 +646,8 @@
 		g_variant_new("(s)", app_id),
 		&error);
 
-	/* Really, Unity? */
-	handshake->timeout = g_timeout_add_seconds(1, unity_too_slow_cb, handshake);
+	/* In case Unity is either not running or taking way too long, we early exit after 5s */
+	handshake->timeout = g_timeout_add_seconds(5, unity_too_slow_cb, handshake);
 
 	return handshake;
 }
@@ -544,15 +658,8 @@
 	if (handshake == NULL)
 		return;
 
+	handshake->mainloop = g_main_loop_new(NULL, FALSE);
 	g_main_loop_run(handshake->mainloop);
-
-	if (handshake->timeout != 0)
-		g_source_remove(handshake->timeout);
-	g_main_loop_unref(handshake->mainloop);
-	g_dbus_connection_signal_unsubscribe(handshake->con, handshake->signal_subscribe);
-	g_object_unref(handshake->con);
-
-	g_free(handshake);
 }
 
 EnvHandle *

=== modified file 'helpers.h'
--- helpers.h	2015-07-15 02:32:54 +0000
+++ helpers.h	2015-12-02 17:21:30 +0000
@@ -21,6 +21,8 @@
 
 typedef struct _EnvHandle EnvHandle;
 
+typedef void (*HandshakeCallback) (gpointer user_data);
+
 gboolean  app_id_to_triplet      (const gchar *   app_id,
                                   gchar **        package,
                                   gchar **        application,
@@ -45,8 +47,11 @@
 void        env_handle_finish    (EnvHandle *     handle);
 
 typedef struct _handshake_t handshake_t;
-handshake_t * starting_handshake_start   (const gchar *   app_id);
-void      starting_handshake_wait        (handshake_t *   handshake);
+handshake_t * starting_handshake_start   (const gchar * app_id,
+                                          HandshakeCallback callback,
+                                          gpointer user_data,
+                                          GDestroyNotify user_data_free);
+void          starting_handshake_wait    (handshake_t *   handshake);
 
 GDBusConnection * cgroup_manager_connection (void);
 void              cgroup_manager_unref (GDBusConnection * cgroup_manager);

=== modified file 'libubuntu-app-launch/click-exec.c'
--- libubuntu-app-launch/click-exec.c	2014-09-17 14:11:59 +0000
+++ libubuntu-app-launch/click-exec.c	2015-12-02 17:21:30 +0000
@@ -51,13 +51,6 @@
 
 	GError * error = NULL;
 
-	handshake_t * handshake = starting_handshake_start(app_id);
-	if (handshake == NULL) {
-		g_warning("Unable to setup starting handshake");
-	}
-
-	ual_tracepoint(click_starting_sent, app_id);
-
 	gchar * package = NULL;
 	/* 'Parse' the App ID */
 	if (!app_id_to_triplet(app_id, &package, NULL, NULL)) {
@@ -160,11 +153,5 @@
 	g_key_file_unref(keyfile);
 	g_free(desktopfile);
 
-	ual_tracepoint(handshake_wait, app_id);
-
-	starting_handshake_wait(handshake);
-
-	ual_tracepoint(handshake_complete, app_id);
-
 	return TRUE;
 }

=== modified file 'libubuntu-app-launch/desktop-exec.c'
--- libubuntu-app-launch/desktop-exec.c	2015-08-12 02:52:05 +0000
+++ libubuntu-app-launch/desktop-exec.c	2015-12-02 17:21:30 +0000
@@ -126,13 +126,6 @@
 
 	ual_tracepoint(desktop_start, app_id);
 
-	handshake_t * handshake = starting_handshake_start(app_id);
-	if (handshake == NULL) {
-		g_warning("Unable to setup starting handshake");
-	}
-
-	ual_tracepoint(desktop_starting_sent, app_id);
-
 	gchar * desktopfilename = NULL;
 	GKeyFile * keyfile = NULL;
 	gchar * libertinecontainer = NULL;
@@ -208,11 +201,5 @@
 
 	g_key_file_free(keyfile);
 
-	ual_tracepoint(handshake_wait, app_id);
-
-	starting_handshake_wait(handshake);
-
-	ual_tracepoint(handshake_complete, app_id);
-
 	return TRUE;
 }

=== modified file 'libubuntu-app-launch/ubuntu-app-launch-trace.tp'
--- libubuntu-app-launch/ubuntu-app-launch-trace.tp	2015-07-15 01:42:22 +0000
+++ libubuntu-app-launch/ubuntu-app-launch-trace.tp	2015-12-02 17:21:30 +0000
@@ -44,6 +44,24 @@
 		ctf_string(appid, appid)
 	)
 )
+TRACEPOINT_EVENT(ubuntu_app_launch, libual_handshake_start,
+	TP_ARGS(const char *, appid),
+	TP_FIELDS(
+		ctf_string(appid, appid)
+	)
+)
+TRACEPOINT_EVENT(ubuntu_app_launch, libual_handshake_wait,
+	TP_ARGS(const char *, appid),
+	TP_FIELDS(
+		ctf_string(appid, appid)
+	)
+)
+TRACEPOINT_EVENT(ubuntu_app_launch, libual_handshake_complete,
+	TP_ARGS(const char *, appid),
+	TP_FIELDS(
+		ctf_string(appid, appid)
+	)
+)
 
 /*******************************
   LibUAL observers
@@ -211,12 +229,6 @@
 		ctf_string(appid, appid)
 	)
 )
-TRACEPOINT_EVENT(ubuntu_app_launch, click_starting_sent,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
 TRACEPOINT_EVENT(ubuntu_app_launch, click_found_pkgdir,
 	TP_ARGS(const char *, appid),
 	TP_FIELDS(
@@ -247,18 +259,6 @@
 		ctf_string(appid, appid)
 	)
 )
-TRACEPOINT_EVENT(ubuntu_app_launch, handshake_wait,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
-TRACEPOINT_EVENT(ubuntu_app_launch, handshake_complete,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
 
 /*******************************
   Desktop Exec
@@ -270,12 +270,6 @@
 		ctf_string(appid, appid)
 	)
 )
-TRACEPOINT_EVENT(ubuntu_app_launch, desktop_starting_sent,
-	TP_ARGS(const char *, appid),
-	TP_FIELDS(
-		ctf_string(appid, appid)
-	)
-)
 TRACEPOINT_EVENT(ubuntu_app_launch, desktop_found,
 	TP_ARGS(const char *, appid),
 	TP_FIELDS(

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.c'
--- libubuntu-app-launch/ubuntu-app-launch.c	2015-12-02 17:21:30 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.c	2015-12-02 17:21:30 +0000
@@ -71,6 +71,14 @@
 } app_start_t;
 
 static void
+app_start_data_free (app_start_t *data)
+{
+	g_free(data->appid);
+	g_free(data->uris);
+	g_free(data);
+}
+
+static void
 application_start_cb (GObject * obj, GAsyncResult * res, gpointer user_data)
 {
 	app_start_t * data = (app_start_t *)user_data;
@@ -101,9 +109,7 @@
 		g_error_free(error);
 	}
 
-	g_free(data->appid);
-	g_free(data->uris);
-	g_free(data);
+	app_start_data_free(data);
 }
 
 /* Get the path of the job from Upstart, if we've got it already, we'll just
@@ -220,8 +226,55 @@
 	}
 }
 
+typedef struct {
+	gchar * jobpath;
+	GVariant * params;
+	app_start_t * app_start_data;
+} handshake_data_t;
+
+static void
+handshake_data_free (handshake_data_t *data)
+{
+	g_free(data->jobpath);
+	g_variant_unref(data->params);
+	app_start_data_free(data->app_start_data);
+	g_free(data);
+}
+
+static void
+handshake_cb (gpointer user_data)
+{
+	handshake_data_t *data = (handshake_data_t *) user_data;
+
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_if_fail(con != NULL);
+
+	/* Copy app start data, so it can be freed by application_start_cb */
+	app_start_t * app_data_copy = g_new0(app_start_t, 1);
+	app_data_copy->appid = g_strdup(data->app_start_data->appid);
+	app_data_copy->uris = g_strdup(data->app_start_data->uris);
+
+	/* Call the job start function */
+	g_dbus_connection_call(con,
+	                       DBUS_SERVICE_UPSTART,
+	                       data->jobpath,
+	                       DBUS_INTERFACE_UPSTART_JOB,
+	                       "Start",
+	                       data->params,
+	                       NULL,
+	                       G_DBUS_CALL_FLAGS_NONE,
+	                       -1,
+	                       NULL, /* cancelable */
+	                       application_start_cb,
+	                       app_data_copy);
+
+	ual_tracepoint(libual_start_message_sent, data->app_start_data->appid);
+
+	g_object_unref(con);
+}
+
 static gboolean
-start_application_core (const gchar * appid, const gchar * const * uris, gboolean test)
+start_application_core (const gchar * appid, const gchar * const * uris, gboolean async, gboolean test)
 {
 	ual_tracepoint(libual_start, appid);
 
@@ -300,24 +353,29 @@
 	if (setup_complete) {
 		g_variant_builder_close(&builder);
 		g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
-	
-		/* Call the job start function */
-		g_dbus_connection_call(con,
-		                       DBUS_SERVICE_UPSTART,
-		                       jobpath,
-		                       DBUS_INTERFACE_UPSTART_JOB,
-		                       "Start",
-		                       g_variant_builder_end(&builder),
-		                       NULL,
-		                       G_DBUS_CALL_FLAGS_NONE,
-		                       -1,
-		                       NULL, /* cancelable */
-		                       application_start_cb,
-		                       app_start_data);
-
-		ual_tracepoint(libual_start_message_sent, appid);
+
+		ual_tracepoint(libual_handshake_start, appid);
+
+		handshake_data_t *handshake_data = g_new0(handshake_data_t, 1);
+		handshake_data->jobpath = g_strdup(jobpath);
+		handshake_data->params = g_variant_ref_sink(g_variant_builder_end(&builder));
+		handshake_data->app_start_data = app_start_data;
+
+		handshake_t * handshake = starting_handshake_start(appid, handshake_cb, handshake_data, (GDestroyNotify)handshake_data_free);
+
+		if (handshake == NULL) {
+			g_warning("Unable to setup starting handshake");
+			setup_complete = FALSE;
+		} else if (!async) {
+			ual_tracepoint(libual_handshake_wait, appid);
+
+			starting_handshake_wait(handshake);
+		}
+
+		ual_tracepoint(libual_handshake_complete, appid);
 	} else {
 		g_variant_builder_clear(&builder);
+		app_start_data_free(app_start_data);
 	}
 
 	g_object_unref(con);
@@ -328,13 +386,25 @@
 gboolean
 ubuntu_app_launch_start_application (const gchar * appid, const gchar * const * uris)
 {
-	return start_application_core(appid, uris, FALSE);
+	return start_application_core(appid, uris, FALSE, FALSE);
 }
 
 gboolean
 ubuntu_app_launch_start_application_test (const gchar * appid, const gchar * const * uris)
 {
-	return start_application_core(appid, uris, TRUE);
+	return start_application_core(appid, uris, FALSE, TRUE);
+}
+
+void
+ubuntu_app_launch_start_application_async (const gchar * appid, const gchar * const * uris)
+{
+	start_application_core(appid, uris, TRUE, FALSE);
+}
+
+void
+ubuntu_app_launch_start_application_async_test (const gchar * appid, const gchar * const * uris)
+{
+	start_application_core(appid, uris, TRUE, TRUE);
 }
 
 static void
@@ -953,7 +1023,7 @@
 	observer_t * observer = (observer_t *)user_data;
 	const gchar * appid = NULL;
 
-	if (observer->func != NULL) {
+	if (observer->func != NULL && g_variant_check_format_string(params, "(s)", FALSE)) {
 		g_variant_get(params, "(&s)", &appid);
 		observer->func(appid, observer->user_data);
 	}
@@ -1007,14 +1077,13 @@
 	return add_session_generic(observer, user_data, "UnityResumeRequest", &resume_array, resume_signal_cb);
 }
 
-/* Handle the starting signal when it occurs, call the observer, then send a signal back when we're done */
+/* Handle the starting signal when it occurs and call the observer,
+   which will send a signal back when it's done via finish_app_starting */
 static void
 starting_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, "starting");
 
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
 	GError * error = NULL;
 	g_dbus_connection_emit_signal(conn,
 		sender, /* destination */
@@ -1027,6 +1096,8 @@
 	if (error != NULL) {
 		g_warning("Unable to emit response signal: %s", error->message);
 		g_error_free(error);
+	} else {
+		generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
 	}
 
 	ual_tracepoint(observer_finish, "starting");
@@ -1038,6 +1109,33 @@
 	return add_session_generic(observer, user_data, "UnityStartingBroadcast", &starting_array, starting_signal_cb);
 }
 
+gboolean
+ubuntu_app_launch_observer_finish_app_starting (const gchar *appid, gboolean approved)
+{
+	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	if (conn == NULL) {
+		return FALSE;
+	}
+
+	GError * error = NULL;
+	g_dbus_connection_emit_signal(conn,
+		NULL, /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(sb)", appid, approved), /* params */
+		&error);
+	g_object_unref(conn);
+
+	if (error != NULL) {
+		g_warning("Unable to emit response signal: %s", error->message);
+		g_error_free(error);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
 /* 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)

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.h'
--- libubuntu-app-launch/ubuntu-app-launch.h	2015-08-10 14:19:05 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.h	2015-12-02 17:21:30 +0000
@@ -97,6 +97,31 @@
                                                          const gchar * const *             uris);
 
 /**
+ * ubuntu_app_launch_start_application_async:
+ * @appid: ID of the application to launch
+ * @uris: (allow-none) (array zero-terminated=1) (element-type utf8) (transfer none): A NULL terminated list of URIs to send to the application
+ *
+ * Asks upstart to launch an application, but does not block.  To discover
+ * whether it successfully started or not, register an observer.  For example,
+ * call ubuntu_app_launch_observer_add_app_started.
+ */
+void   ubuntu_app_launch_start_application_async         (const gchar *                     appid,
+                                                          const gchar * const *             uris);
+
+/**
+ * ubuntu_app_launch_start_application_async_test:
+ * @appid: ID of the application to launch
+ * @uris: (allow-none) (array zero-terminated=1) (element-type utf8) (transfer none): A NULL terminated list of URIs to send to the application
+ *
+ * Asks upstart to launch an application with environment variables set
+ * to enable testing, but does not block.  To discover whether it successfully
+ * started or not, register an observer.  For example, call
+ * ubuntu_app_launch_observer_add_app_started.  Should only be used in testing.
+ */
+void   ubuntu_app_launch_start_application_async_test    (const gchar *                     appid,
+                                                          const gchar * const *             uris);
+
+/**
  * ubuntu_app_launch_stop_application:
  * @appid: ID of the application to launch
  *
@@ -163,14 +188,28 @@
  * @user_data: (closure) (allow-none): Data to pass to the observer
  *
  * Sets up a callback to get called each time an application
- * is about to start.  The application will not start until the
- * function returns.
+ * is about to start.  The application will not start until
+ * ubuntu_app_launch_observer_finish_app_starting is called after
+ * the callback is called.
  *
  * Return value: Whether adding the observer was successful.
  */
 gboolean   ubuntu_app_launch_observer_add_app_starting (UbuntuAppLaunchAppObserver       observer,
                                                          gpointer                          user_data);
 /**
+ * ubuntu_app_launch_observer_finish_app_starting:
+ * @appid: ID of the application being started
+ * @approved: Whether the app can continue starting
+ *
+ * Finishes handling an app that is starting up via the callback
+ * registered with ubuntu_app_launch_observer_add_app_starting.
+ * If the app is allowed to continue starting, pass TRUE.
+ *
+ * Return value: Whether finish app startup was successful.
+ */
+gboolean   ubuntu_app_launch_observer_finish_app_starting (const gchar *appid,
+                                                           gboolean     approved);
+/**
  * ubuntu_app_launch_observer_add_app_started:
  * @observer: (scope notified): Callback when an application started
  * @user_data: (closure) (allow-none): Data to pass to the observer

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-06-26 17:26:50 +0000
+++ tests/CMakeLists.txt	2015-12-02 17:21:30 +0000
@@ -24,7 +24,7 @@
 # Helper test
 
 add_executable (helper-handshake-test helper-handshake-test.cc)
-target_link_libraries (helper-handshake-test helpers gtest ${GTEST_LIBS})
+target_link_libraries (helper-handshake-test helpers-test gtest ${GTEST_LIBS})
 
 add_test (helper-handshake-test helper-handshake-test)
 

=== modified file 'tests/exec-util-test.cc'
--- tests/exec-util-test.cc	2015-08-11 19:11:15 +0000
+++ tests/exec-util-test.cc	2015-12-02 17:21:30 +0000
@@ -34,7 +34,8 @@
 
 	protected:
 		static void starting_cb (const gchar * appid, gpointer user_data) {
-			g_debug("I'm too sexy to callback");
+			g_debug("Starting app %s", appid);
+			ASSERT_TRUE(ubuntu_app_launch_observer_finish_app_starting(appid, TRUE));
 		}
 
 		virtual void SetUp() {

=== modified file 'tests/helper-handshake-test.cc'
--- tests/helper-handshake-test.cc	2014-04-30 16:18:29 +0000
+++ tests/helper-handshake-test.cc	2015-12-02 17:21:30 +0000
@@ -72,12 +72,20 @@
 	return static_cast<HelperHandshakeTest *>(user_data)->FilterFunc(conn, message, incomming);
 }
 
+static void
+handshake_cb (gpointer user_data)
+{
+	bool * reached = static_cast<bool *>(user_data);
+	*reached = true;
+}
+
 TEST_F(HelperHandshakeTest, BaseHandshake)
 {
+	bool handshake_succeeded = false;
 	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
 	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
 
-	handshake_t * handshake = starting_handshake_start("fooapp");
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
 
 	g_main_loop_run(mainloop);
 
@@ -91,8 +99,89 @@
 		g_variant_new("(s)", "fooapp"), /* params, the same */
 		NULL);
 
-	starting_handshake_wait(handshake);
-
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(sb)", "fooapp", TRUE), /* params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_TRUE(handshake_succeeded);
+	g_object_unref(con);
+
+	return;
+}
+
+TEST_F(HelperHandshakeTest, UnapprovedHandshake)
+{
+	bool handshake_succeeded = false;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+
+	g_main_loop_run(mainloop);
+
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingSignal", /* signal */
+		g_variant_new("(s)", "fooapp"), /* params */
+		NULL);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(sb)", "fooapp", FALSE), /* params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_FALSE(handshake_succeeded);
+	g_object_unref(con);
+
+	return;
+}
+
+TEST_F(HelperHandshakeTest, InvalidHandshake)
+{
+	bool handshake_succeeded = false;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+
+	g_main_loop_run(mainloop);
+
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingSignal", /* signal */
+		g_variant_new("(s)", "fooapp"), /* params */
+		NULL);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(ss)", "fooapp", "true"), /* bad params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_FALSE(handshake_succeeded);
 	g_object_unref(con);
 
 	return;
@@ -103,18 +192,179 @@
 {
 	bool * reached = static_cast<bool *>(user_data);
 	*reached = true;
+	return G_SOURCE_REMOVE;
 }
 
 TEST_F(HelperHandshakeTest, HandshakeTimeout)
 {
 	bool timeout_reached = false;
-	handshake_t * handshake = starting_handshake_start("fooapp");
-
-	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, &timeout_reached);
-
-	starting_handshake_wait(handshake);
-
-	ASSERT_FALSE(timeout_reached);
-
-	return;
-}
+	bool handshake_succeeded = false;
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+
+	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, &timeout_reached);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_FALSE(timeout_reached);
+	ASSERT_FALSE(handshake_succeeded);
+	g_source_remove(outertimeout);
+
+	return;
+}
+
+TEST_F(HelperHandshakeTest, HandshakeTimeoutWithOnlyApprovedSignal)
+{
+	bool timeout_reached = false;
+	bool handshake_succeeded = false;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, &timeout_reached);
+
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+	g_main_loop_run(mainloop);
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(sb)", "fooapp", true), /* bad params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_FALSE(timeout_reached);
+	ASSERT_FALSE(handshake_succeeded);
+	g_source_remove(outertimeout);
+	g_object_unref(con);
+
+	return;
+}
+
+static gboolean
+emit_approval (gpointer user_data)
+{
+	GDBusConnection * con = (GDBusConnection *) user_data;
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingApproved", /* signal */
+		g_variant_new("(sb)", "fooapp", true), /* params */
+		NULL);
+
+	return G_SOURCE_REMOVE;
+}
+
+TEST_F(HelperHandshakeTest, HandshakeNoTimeoutWithReceivedSignal)
+{
+	bool timeout_reached = false;
+	bool handshake_succeeded = false;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+	g_timeout_add_seconds(2, two_second_reached, &timeout_reached);
+	g_timeout_add_seconds(2, emit_approval, con);
+
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+	g_main_loop_run(mainloop);
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingSignal", /* signal */
+		g_variant_new("(s)", "fooapp"), /* params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_TRUE(timeout_reached);
+	ASSERT_TRUE(handshake_succeeded);
+	g_object_unref(con);
+
+	return;
+}
+
+TEST_F(HelperHandshakeTest, AsyncHandshake)
+{
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+	g_timeout_add_seconds(2, emit_approval, con);
+
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+	handshake_t * handshake = starting_handshake_start("fooapp", (HandshakeCallback)g_main_loop_quit, mainloop, NULL);
+	g_main_loop_run(mainloop);
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingSignal", /* signal */
+		g_variant_new("(s)", "fooapp"), /* params, the same */
+		NULL);
+
+	g_main_loop_run(mainloop);
+
+	g_object_unref(con);
+
+	return;
+}
+
+static gboolean
+emit_name_change (gpointer user_data)
+{
+	GDBusConnection * con = (GDBusConnection *) user_data;
+	const gchar *unique_name = g_dbus_connection_get_unique_name(con);
+
+	// We are allowed to emit this (instead of DBus) because we link against
+	// helpers-test, a special version of the helper code that listens
+	// for this signal from anyone.
+	g_dbus_connection_emit_signal(con,
+		unique_name, /* destination */
+		"/org/freedesktop/DBus", /* path */
+		"org.freedesktop.DBus", /* interface */
+		"NameOwnerChanged", /* signal */
+		g_variant_new("(sss)", unique_name, unique_name, ""), /* params */
+		NULL);
+
+	return G_SOURCE_REMOVE;
+}
+
+TEST_F(HelperHandshakeTest, StopsWaitingIfUnityExits)
+{
+	bool timeout_reached = false;
+	bool handshake_succeeded = false;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+	g_timeout_add_seconds(1, emit_name_change, con);
+	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, &timeout_reached);
+
+	guint filter = g_dbus_connection_add_filter(con, filter_func, this, NULL);
+	handshake_t * handshake = starting_handshake_start("fooapp", handshake_cb, &handshake_succeeded, NULL);
+	g_main_loop_run(mainloop);
+	g_dbus_connection_remove_filter(con, filter);
+
+	g_dbus_connection_emit_signal(con,
+		g_dbus_connection_get_unique_name(con), /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		"UnityStartingSignal", /* signal */
+		g_variant_new("(s)", "fooapp"), /* params */
+		NULL);
+
+	starting_handshake_wait(handshake);
+
+	ASSERT_FALSE(timeout_reached);
+	ASSERT_FALSE(handshake_succeeded);
+	g_source_remove(outertimeout);
+	g_object_unref(con);
+
+	return;
+}
+

=== modified file 'tests/libual-test.cc'
--- tests/libual-test.cc	2015-08-12 02:45:40 +0000
+++ tests/libual-test.cc	2015-12-02 17:21:30 +0000
@@ -38,11 +38,19 @@
 		DbusTestDbusMock * mock = NULL;
 		DbusTestDbusMock * cgmock = NULL;
 		GDBusConnection * bus = NULL;
+		std::string last_starting_appid;
 		std::string last_focus_appid;
 		std::string last_resume_appid;
 		guint resume_timeout = 0;
 
 	private:
+		static void starting_cb (const gchar * appid, gpointer user_data) {
+			g_debug("Starting Callback: %s", appid);
+			LibUAL * _this = static_cast<LibUAL *>(user_data);
+			_this->last_starting_appid = appid;
+			ASSERT_TRUE(ubuntu_app_launch_observer_finish_app_starting(appid, TRUE));
+		}
+
 		static void focus_cb (const gchar * appid, gpointer user_data) {
 			g_debug("Focus Callback: %s", appid);
 			LibUAL * _this = static_cast<LibUAL *>(user_data);
@@ -258,11 +266,13 @@
 			/* 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_starting(starting_cb, this));
 			ASSERT_TRUE(ubuntu_app_launch_observer_add_app_focus(focus_cb, this));
 			ASSERT_TRUE(ubuntu_app_launch_observer_add_app_resume(resume_cb, this));
 		}
 
 		virtual void TearDown() {
+			ubuntu_app_launch_observer_delete_app_starting(starting_cb, this);
 			ubuntu_app_launch_observer_delete_app_focus(focus_cb, this);
 			ubuntu_app_launch_observer_delete_app_resume(resume_cb, this);
 
@@ -426,6 +436,140 @@
 	g_variant_unref(env);
 }
 
+typedef struct {
+	int count;
+	GMainLoop *loop;
+} async_data_t;
+
+static void
+async_test_app_focused_cb (const gchar * appid, gpointer user_data)
+{
+	async_data_t * data = (async_data_t *)user_data;
+	data->count++;
+	g_main_loop_quit(data->loop);
+}
+
+static gboolean
+two_second_reached (gpointer user_data)
+{
+	GMainLoop * loop = (GMainLoop *)user_data;
+	g_main_loop_quit(loop);
+	return G_SOURCE_REMOVE;
+}
+
+TEST_F(LibUAL, StartApplicationAsync)
+{
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
+
+	async_data_t data = {
+		.count = 0,
+		.loop = g_main_loop_new(NULL, FALSE)
+	};
+
+	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_focus(async_test_app_focused_cb, &data));
+
+	/* Basic make sure we can send the event */
+	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, data.loop);
+	ubuntu_app_launch_start_application_async("com.test.good_application_1.2.3", NULL);
+	g_main_loop_run(data.loop);
+	g_source_remove(outertimeout);
+	ASSERT_EQ(1, data.count);
+
+	EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	/* Now look at the details of the call */
+	outertimeout = g_timeout_add_seconds(2, two_second_reached, data.loop);
+	ubuntu_app_launch_start_application_async("com.test.good_application_1.2.3", NULL);
+	g_main_loop_run(data.loop);
+	g_source_remove(outertimeout);
+	ASSERT_EQ(2, data.count);
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	GVariant * block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
+	g_variant_unref(block);
+
+	GVariant * env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "com.test.good_application_1.2.3"));
+	g_variant_unref(env);
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	/* Let's pass some URLs */
+	const gchar * urls[] = {
+		"http://ubuntu.com/",
+		"https://ubuntu.com/",
+		"file:///home/phablet/test.txt",
+		NULL
+	};
+	outertimeout = g_timeout_add_seconds(2, two_second_reached, data.loop);
+	ubuntu_app_launch_start_application("com.test.good_application_1.2.3", urls);
+	g_main_loop_run(data.loop);
+	g_source_remove(outertimeout);
+	ASSERT_EQ(3, data.count);
+
+	len = 0;
+	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "com.test.good_application_1.2.3"));
+	EXPECT_TRUE(check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
+	g_variant_unref(env);
+
+	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_focus(async_test_app_focused_cb, &data));
+	g_main_loop_unref(data.loop);
+
+	return;
+}
+
+TEST_F(LibUAL, StartApplicationAsyncTest)
+{
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
+
+	async_data_t data = {
+		.count = 0,
+		.loop = g_main_loop_new(NULL, FALSE)
+	};
+
+	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_focus(async_test_app_focused_cb, &data));
+
+	guint outertimeout = g_timeout_add_seconds(2, two_second_reached, data.loop);
+	ubuntu_app_launch_start_application_async_test("com.test.good_application_1.2.3", NULL);
+	g_main_loop_run(data.loop);
+	g_source_remove(outertimeout);
+	ASSERT_EQ(1, data.count);
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	GVariant * block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
+	g_variant_unref(block);
+
+	GVariant * env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "com.test.good_application_1.2.3"));
+	EXPECT_TRUE(check_env(env, "QT_LOAD_TESTABILITY", "1"));
+	g_variant_unref(env);
+
+	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_focus(async_test_app_focused_cb, &data));
+	g_main_loop_unref(data.loop);
+}
+
 TEST_F(LibUAL, StopApplication)
 {
 	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
@@ -748,7 +892,6 @@
 
 TEST_F(LibUAL, StartingResponses)
 {
-	std::string last_observer;
 	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,
@@ -756,8 +899,6 @@
 		&starting_count,
 		NULL);
 
-	EXPECT_TRUE(ubuntu_app_launch_observer_add_app_starting(starting_observer, &last_observer));
-
 	g_dbus_connection_emit_signal(session,
 		NULL, /* destination */
 		"/", /* path */
@@ -768,11 +909,9 @@
 
 	pause(100);
 
-	EXPECT_EQ("com.test.good_application_1.2.3", last_observer);
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_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);
 }
@@ -781,6 +920,7 @@
 {
 	ASSERT_TRUE(ubuntu_app_launch_start_application("com.test.good_application_1.2.3", NULL));
 	pause(50); /* Ensure all the events come through */
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 }
@@ -817,6 +957,7 @@
 	ASSERT_TRUE(ubuntu_app_launch_start_application("com.test.good_application_1.2.3", uris));
 	pause(100); /* Ensure all the events come through */
 
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 
@@ -851,6 +992,7 @@
 	ASSERT_TRUE(ubuntu_app_launch_start_application("com.test.good_application_1.2.3", uris));
 	pause(100); /* Ensure all the events come through */
 
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 }
@@ -861,6 +1003,7 @@
 
 	ASSERT_TRUE(ubuntu_app_launch_start_application("com.test.good_application_1.2.3", NULL));
 	pause(1000); /* Ensure all the events come through */
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 }
@@ -876,6 +1019,7 @@
 
 	ASSERT_TRUE(ubuntu_app_launch_start_application("com.test.good_application_1.2.3", uris));
 	pause(1000); /* Ensure all the events come through */
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 }
@@ -915,6 +1059,7 @@
 
 	pause(1000); /* Ensure all the events come through */
 
+	EXPECT_EQ("com.test.good_application_1.2.3", this->last_starting_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_focus_appid);
 	EXPECT_EQ("com.test.good_application_1.2.3", this->last_resume_appid);
 

=== modified file 'tools/ubuntu-app-watch.c'
--- tools/ubuntu-app-watch.c	2015-02-25 22:50:24 +0000
+++ tools/ubuntu-app-watch.c	2015-12-02 17:21:30 +0000
@@ -23,6 +23,7 @@
 starting (const gchar * appid, gpointer user_data)
 {
 	g_print("Starting %s\n", appid);
+	ubuntu_app_launch_observer_finish_app_starting(appid, TRUE);
 	return;
 }