Merge lp:~ted/ubuntu-app-launch/suspend-signal into lp:ubuntu-app-launch/15.04

[Ted Gould]

Emit a signal when applications are paused or resumed

This way services can respond appropriately whether they're getting the message.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:195
http://jenkins.qa.ubuntu.com/job/upstart-app-launch-ci/313/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-armhf-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-i386-ci/8/console

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

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/suspend-signal]

196. By Ted Gould on 2015-03-03

Add in symbols

197. By Ted Gould on 2015-03-03

Attaching bug

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:197
http://jenkins.qa.ubuntu.com/job/upstart-app-launch-ci/314/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-amd64-ci/9/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-armhf-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-i386-ci/9

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:197
http://jenkins.qa.ubuntu.com/job/upstart-app-launch-ci/315/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-amd64-ci/10/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-armhf-ci/10
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-i386-ci/10

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

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/suspend-signal]

198. By Ted Gould on 2015-03-04

Adding to the informational dbus xml file

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:198
http://jenkins.qa.ubuntu.com/job/upstart-app-launch-ci/316/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-amd64-ci/11/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-armhf-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-i386-ci/11

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:198
http://jenkins.qa.ubuntu.com/job/upstart-app-launch-ci/317/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-armhf-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/upstart-app-launch-vivid-i386-ci/12

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

review: Approve (continuous-integration)

[dobey (dobey)]

I don't like the @replaceme as it means CI train ends up modifying the change set when it lands in trunk, but otherwise looks OK.

review: Approve

=== modified file 'data/com.canonical.UbuntuAppLaunch.xml'
--- data/com.canonical.UbuntuAppLaunch.xml	2014-04-30 15:45:23 +0000
+++ data/com.canonical.UbuntuAppLaunch.xml	2015-03-04 14:26:50 +0000
@@ -20,5 +20,13 @@
 			<arg type="s" name="appid" />
 			<arg type="s" name="stage" />
 		</signal>
+		<signal name="ApplicationPaused">
+			<arg type="s" name="appid" />
+			<arg type="at" name="pids" />
+		</signal>
+		<signal name="ApplicationResumed">
+			<arg type="s" name="appid" />
+			<arg type="at" name="pids" />
+		</signal>
 	</interface>
 </node>

=== modified file 'debian/libubuntu-app-launch2.symbols'
--- debian/libubuntu-app-launch2.symbols	2014-09-15 19:40:14 +0000
+++ debian/libubuntu-app-launch2.symbols	2015-03-04 14:26:50 +0000
@@ -7,7 +7,9 @@
  ubuntu_app_launch_list_running_apps@Base 0.4
  ubuntu_app_launch_observer_add_app_failed@Base 0.4
  ubuntu_app_launch_observer_add_app_focus@Base 0.4
+ ubuntu_app_launch_observer_add_app_paused@Base 0replaceme
  ubuntu_app_launch_observer_add_app_resume@Base 0.4
+ ubuntu_app_launch_observer_add_app_resumed@Base 0replaceme
  ubuntu_app_launch_observer_add_app_started@Base 0.4
  ubuntu_app_launch_observer_add_app_starting@Base 0.4
  ubuntu_app_launch_observer_add_app_stop@Base 0.4
@@ -15,7 +17,9 @@
  ubuntu_app_launch_observer_add_helper_stop@Base 0.4
  ubuntu_app_launch_observer_delete_app_failed@Base 0.4
  ubuntu_app_launch_observer_delete_app_focus@Base 0.4
+ ubuntu_app_launch_observer_delete_app_paused@Base 0replaceme
  ubuntu_app_launch_observer_delete_app_resume@Base 0.4
+ ubuntu_app_launch_observer_delete_app_resumed@Base 0replaceme
  ubuntu_app_launch_observer_delete_app_started@Base 0.4
  ubuntu_app_launch_observer_delete_app_starting@Base 0.4
  ubuntu_app_launch_observer_delete_app_stop@Base 0.4

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.c'
--- libubuntu-app-launch/ubuntu-app-launch.c	2014-11-20 20:33:59 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.c	2015-03-04 14:26:50 +0000
@@ -499,10 +499,61 @@
 	return FALSE;
 }
 
+/* Throw out a DBus signal that we've signalled all of these processes. This
+   is the fun GVariant building part. */
+static void
+notify_signalling (GList * pids, const gchar * appid, const gchar * signal_name)
+{
+	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	if (conn == NULL) {
+		return;
+	}
+
+	/* Pull together a PID array */
+	GVariant *pidarray = NULL;
+	if (pids == NULL) {
+		pidarray = g_variant_new_array(G_VARIANT_TYPE_UINT64, NULL, 0);
+	} else {
+		GList * i;
+		GVariantBuilder builder;
+		g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+
+		for (i = pids; i != NULL; i = g_list_next(i))
+			g_variant_builder_add_value(&builder, g_variant_new_uint64(GPOINTER_TO_INT(i->data)));
+
+		pidarray = g_variant_builder_end(&builder);
+	}
+
+	/* Combine into the wrapping tuple */
+	GVariantBuilder btuple;
+	g_variant_builder_init(&btuple, G_VARIANT_TYPE_TUPLE);
+	g_variant_builder_add_value(&btuple, g_variant_new_string(appid));
+	g_variant_builder_add_value(&btuple, pidarray);
+
+	/* Emit !!! */
+	GError * error = NULL;
+	g_dbus_connection_emit_signal(conn,
+		NULL, /* destination */
+		"/", /* path */
+		"com.canonical.UbuntuAppLaunch", /* interface */
+		signal_name, /* signal */
+		g_variant_builder_end(&btuple), /* params, the same */
+		&error);
+
+	if (error != NULL) {
+		g_warning("Unable to emit signal '%s' for appid '%s': %s", signal_name, appid, error->message);
+		g_error_free(error);
+	} else {
+		g_debug("Emmitted '%s' to DBus", signal_name);
+	}
+
+	g_object_unref(conn);
+}
+
 /* Gets all the pids for an appid and sends a signal to all of them. This also
    loops to ensure no new pids are added while we're signaling */
 static gboolean
-signal_to_cgroup (const gchar * appid, int signal, const gchar * oomscore)
+signal_to_cgroup (const gchar * appid, int signal, const gchar * oomscore, const gchar * signal_name)
 {
 	GHashTable * pidssignaled = g_hash_table_new(g_direct_hash, g_direct_equal);
 	guint hash_table_size = 0;
@@ -543,6 +594,7 @@
 	/* If it grew, then try again */
 	} while (hash_table_size != g_hash_table_size(pidssignaled));
 
+	notify_signalling(g_hash_table_get_keys(pidssignaled), appid, signal_name);
 	g_hash_table_destroy(pidssignaled);
 
 	return retval;
@@ -612,14 +664,14 @@
 ubuntu_app_launch_pause_application (const gchar * appid)
 {
 	report_zg_event(appid, ZEITGEIST_ZG_LEAVE_EVENT);
-	return signal_to_cgroup(appid, SIGSTOP, "900");
+	return signal_to_cgroup(appid, SIGSTOP, "900", "ApplicationPaused");
 }
 
 gboolean
 ubuntu_app_launch_resume_application (const gchar * appid)
 {
 	report_zg_event(appid, ZEITGEIST_ZG_ACCESS_EVENT);
-	return signal_to_cgroup(appid, SIGCONT, "100");
+	return signal_to_cgroup(appid, SIGCONT, "100", "ApplicationResumed");
 }
 
 gchar *
@@ -709,6 +761,16 @@
 	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;
@@ -716,6 +778,8 @@
 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)
@@ -994,6 +1058,81 @@
 	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)
 {
@@ -1078,6 +1217,45 @@
 	return TRUE;
 }
 
+static gboolean
+paused_resumed_delete (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data, GList ** list)
+{
+	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);
+
+	return TRUE;
+}
+
+gboolean
+ubuntu_app_launch_observer_delete_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
+{
+	return paused_resumed_delete(observer, user_data, &paused_array);
+}
+
+gboolean
+ubuntu_app_launch_observer_delete_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
+{
+	return paused_resumed_delete(observer, user_data, &resumed_array);
+}
+
 typedef void (*per_instance_func_t) (GDBusConnection * con, GVariant * prop_dict, gpointer user_data);
 
 static void

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.h'
--- libubuntu-app-launch/ubuntu-app-launch.h	2014-08-13 15:11:45 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.h	2015-03-04 14:26:50 +0000
@@ -53,6 +53,15 @@
 typedef void (*UbuntuAppLaunchAppFailedObserver) (const gchar * appid, UbuntuAppLaunchAppFailed failure_type, gpointer user_data);
 
 /**
+ * UbuntuAppLaunchAppPausedResumedObserver:
+ * @appid: App ID of the application being paused
+ * @pids: Zero terminated array of PIDs
+ *
+ * Function prototype for application paused and resumed observers.
+ */
+typedef void (*UbuntuAppLaunchAppPausedResumedObserver) (const gchar * appid, GPid * pids, gpointer user_data);
+
+/**
  * UbuntuAppLaunchHelperObserver:
  *
  * Function to watch for helpers that are starting and stopping
@@ -210,6 +219,32 @@
                                                          gpointer                          user_data);
 
 /**
+ * ubuntu_app_launch_observer_add_app_paused:
+ * @observer: (scope notified): Callback when an application is paused
+ * @user_data: (allow-none) (closure): Data to pass to the observer
+ *
+ * Sets up a callback to get called each time an application
+ * is paused.
+ *
+ * Return value: Whether adding the observer was successful.
+ */
+gboolean   ubuntu_app_launch_observer_add_app_paused   (UbuntuAppLaunchAppPausedResumedObserver observer,
+                                                        gpointer                                user_data);
+
+/**
+ * ubuntu_app_launch_observer_add_app_resumed:
+ * @observer: (scope notified): Callback when an application is resumed
+ * @user_data: (allow-none) (closure): Data to pass to the observer
+ *
+ * Sets up a callback to get called each time an application
+ * is resumed. Which is after the SIGCONT has been sent to the pids.
+ *
+ * Return value: Whether adding the observer was successful.
+ */
+gboolean   ubuntu_app_launch_observer_add_app_resumed  (UbuntuAppLaunchAppPausedResumedObserver observer,
+                                                        gpointer                                user_data);
+
+/**
  * ubuntu_app_launch_observer_delete_app_starting:
  * @observer: (scope notified): Callback to remove
  * @user_data: (closure) (allow-none): Data that was passed to the observer
@@ -221,6 +256,7 @@
  */
 gboolean   ubuntu_app_launch_observer_delete_app_starting (UbuntuAppLaunchAppObserver       observer,
                                                             gpointer                          user_data);
+
 /**
  * ubuntu_app_launch_observer_delete_app_started:
  * @observer: (scope notified): Callback to remove
@@ -284,6 +320,33 @@
  */
 gboolean   ubuntu_app_launch_observer_delete_app_failed (UbuntuAppLaunchAppFailedObserver        observer,
                                                           gpointer                                 user_data);
+
+/**
+ * ubuntu_app_launch_observer_delete_app_paused:
+ * @observer: (scope notified): Callback to remove
+ * @user_data: (closure) (allow-none): Data to pass to the observer
+ *
+ * Removes a previously registered callback to ensure it no longer
+ * gets signaled.
+ *
+ * Return value: Whether deleting the observer was successful.
+ */
+gboolean   ubuntu_app_launch_observer_delete_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer,
+                                                         gpointer                                user_data);
+
+/**
+ * ubuntu_app_launch_observer_delete_app_resumed:
+ * @observer: (scope notified): Callback to remove
+ * @user_data: (closure) (allow-none): Data to pass to the observer
+ *
+ * Removes a previously registered callback to ensure it no longer
+ * gets signaled.
+ *
+ * Return value: Whether deleting the observer was successful.
+ */
+gboolean   ubuntu_app_launch_observer_delete_app_resumed (UbuntuAppLaunchAppPausedResumedObserver  observer,
+                                                          gpointer                                 user_data);
+
 /**
  * ubuntu_app_launch_list_running_apps:
  *

=== modified file 'tests/libual-test.cc'
--- tests/libual-test.cc	2014-10-28 12:43:11 +0000
+++ tests/libual-test.cc	2015-03-04 14:26:50 +0000
@@ -1272,6 +1272,14 @@
 	return TRUE;
 }
 
+static void
+signal_increment (GDBusConnection * connection, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+{
+	guint * count = (guint *)user_data;
+	g_debug("Count incremented to: %d", *count + 1);
+	*count = *count + 1;
+}
+
 TEST_F(LibUAL, PauseResume)
 {
 	g_setenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH", CMAKE_BINARY_DIR "/libual-proc" , 1);
@@ -1342,8 +1350,33 @@
 	} while (dbus_test_task_get_state(DBUS_TEST_TASK(cgmock2)) != DBUS_TEST_TASK_STATE_RUNNING &&
 		dbus_test_task_get_state(DBUS_TEST_TASK(zgmock)) != DBUS_TEST_TASK_STATE_RUNNING);
 
+	/* Setup signal handling */
+	guint paused_count = 0;
+	guint resumed_count = 0;
+	guint paused_signal = g_dbus_connection_signal_subscribe(bus,
+		nullptr,
+		"com.canonical.UbuntuAppLaunch",
+		"ApplicationPaused",
+		"/",
+		nullptr,
+		G_DBUS_SIGNAL_FLAGS_NONE,
+		signal_increment,
+		&paused_count,
+		nullptr);
+	guint resumed_signal = g_dbus_connection_signal_subscribe(bus,
+		nullptr,
+		"com.canonical.UbuntuAppLaunch",
+		"ApplicationResumed",
+		"/",
+		nullptr,
+		G_DBUS_SIGNAL_FLAGS_NONE,
+		signal_increment,
+		&resumed_count,
+		nullptr);
+
 	/* Test it */
 	EXPECT_NE(0, datacnt);
+	paused_count = 0;
 
 	/* Pause the app */
 	EXPECT_TRUE(ubuntu_app_launch_pause_application("com.test.good_application_1.2.3"));
@@ -1354,6 +1387,7 @@
 	pause(200);
 
 	/* Check data coming out */
+	EXPECT_EQ(1, paused_count);
 	EXPECT_EQ(0, datacnt);
 
 	/* Check to make sure we sent the event to ZG */
@@ -1370,6 +1404,7 @@
 	ASSERT_TRUE(g_file_get_contents(oomadjfile, &pauseoomscore, NULL, NULL));
 	EXPECT_STREQ("900", pauseoomscore);
 	g_free(pauseoomscore);
+	resumed_count = 0;
 
 	/* Now Resume the App */
 	EXPECT_TRUE(ubuntu_app_launch_resume_application("com.test.good_application_1.2.3"));
@@ -1377,6 +1412,7 @@
 	pause(200);
 
 	EXPECT_NE(0, datacnt);
+	EXPECT_EQ(1, resumed_count);
 
 	/* Check to make sure we sent the event to ZG */
 	numcalls = 0;
@@ -1400,6 +1436,9 @@
 
 	g_spawn_command_line_sync("rm -rf " CMAKE_BINARY_DIR "/libual-proc", NULL, NULL, NULL, NULL);
 
+	g_dbus_connection_signal_unsubscribe(bus, paused_signal);
+	g_dbus_connection_signal_unsubscribe(bus, resumed_signal);
+
 	/* Kill ZG default instance :-( */
 	ZeitgeistLog * log = zeitgeist_log_get_default();
 	g_object_unref(log);

=== modified file 'tools/ubuntu-app-watch.c'
--- tools/ubuntu-app-watch.c	2014-04-30 16:34:06 +0000
+++ tools/ubuntu-app-watch.c	2015-03-04 14:26:50 +0000
@@ -41,9 +41,16 @@
 }
 
 void
-resume (const gchar * appid, gpointer user_data)
-{
-	g_print("Resume   %s\n", appid);
+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;
 }
 
@@ -79,7 +86,8 @@
 	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_resume(resume, 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);
@@ -89,7 +97,8 @@
 	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_resume(resume, 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);