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

[Ted Gould]

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

230. By Ted Gould on 2016-02-08

These shouldn't have ever been there

231. By Ted Gould on 2016-02-08

Merge in code style changes

232. By Ted Gould on 2016-02-08

Apply new style to launch and watch

233. By Ted Gould on 2016-03-03

Catching up to the base branch

234. By Ted Gould on 2016-05-16

Updated to trunk

235. By Ted Gould on 2016-05-16

Make the signal access functions

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/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-02-08 22:18:14 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-02-08 22:18:15 +0000
@@ -38,7 +38,7 @@
               _dbus.reset();
           })
     , _registry(registry)
-// _manager(nullptr)
+    , _manager(nullptr)
 {
     auto cancel = thread.getCancellable();
     _dbus = thread.executeOnThread<std::shared_ptr<GDBusConnection>>(
@@ -195,7 +195,6 @@
                                                });
 }
 
-#if 0
 void
 Registry::Impl::setManager (Registry::Manager* manager)
 {
@@ -212,7 +211,6 @@
 {
     _manager = nullptr;
 }
-#endif
 
 };  // namespace AppLaunch
 };  // namespace Ubuntu

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-02-08 22:18:14 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-02-08 22:18:15 +0000
@@ -44,18 +44,14 @@
     std::list<AppID::Package> getClickPackages();
     std::string getClickDir(const std::string& package);
 
-#if 0
     void setManager (Registry::Manager* manager);
     void clearManager ();
-#endif
 
     GLib::ContextThread thread;
 
 private:
     Registry* _registry;
-#if 0
     Registry::Manager* _manager;
-#endif
 
     std::shared_ptr<ClickDB> _clickDB;
     std::shared_ptr<ClickUser> _clickUser;

=== modified file 'libubuntu-app-launch/registry.h'
--- libubuntu-app-launch/registry.h	2016-02-08 22:18:14 +0000
+++ libubuntu-app-launch/registry.h	2016-02-08 22:18:15 +0000
@@ -49,7 +49,6 @@
     static std::list<std::shared_ptr<Application>> runningApps(std::shared_ptr<Registry> registry = getDefault());
     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;
@@ -70,7 +69,6 @@
 
     void setManager (Manager* manager);
     void clearManager ();
-#endif
 
     /* Helper Lists */
     static std::list<std::shared_ptr<Helper>> runningHelpers(Helper::Type type,

=== modified file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	2016-02-08 22:18:14 +0000
+++ tools/CMakeLists.txt	2016-02-08 22:18:15 +0000
@@ -21,7 +21,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}")
@@ -30,7 +30,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}")

=== renamed file 'tools/ubuntu-app-launch.c' => 'tools/ubuntu-app-launch.cpp'
--- tools/ubuntu-app-launch.c	2014-04-30 16:34:06 +0000
+++ tools/ubuntu-app-launch.cpp	2016-02-08 22:18:15 +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,64 @@
  *     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 <iostream>
+#include <future>
+#include <csignal>
+#include "libubuntu-app-launch/application.h"
+#include "libubuntu-app-launch/registry.h"
+
+Ubuntu::AppLaunch::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::AppLaunch::AppID::parse(argv[1]);
+
+    std::vector<Ubuntu::AppLaunch::Application::URL> urls;
+    for (int i = 2; i < argc; i++)
+    {
+        urls.push_back(Ubuntu::AppLaunch::Application::URL::from_raw(argv[i]));
+    }
+
+    auto registry = std::make_shared<Ubuntu::AppLaunch::Registry>();
+
+    registry->appStarted.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                    std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance)
+                                 {
+                                     if (app->appId() != global_appid)
+                                     {
+                                         return;
+                                     }
+
+                                     std::cout << "Started: " << (std::string)app->appId() << std::endl;
+                                     retval.set_value(0);
+                                 });
+
+    registry->appFailed.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                   std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance,
+                                   Ubuntu::AppLaunch::Registry::FailureType type)
+                                {
+                                    if (app->appId() != global_appid)
+                                    {
+                                        return;
+                                    }
+
+                                    std::cout << "Failed:  " << (std::string)app->appId() << std::endl;
+                                    retval.set_value(-1);
+                                });
+
+    auto app = Ubuntu::AppLaunch::Application::create(global_appid, registry);
+    app->launch(urls);
+
+    std::signal(SIGTERM, [](int signal) -> void
+                         {
+                             retval.set_value(0);
+                         });
+    return retval.get_future().get();
 }

=== renamed file 'tools/ubuntu-app-watch.c' => 'tools/ubuntu-app-watch.cpp'
--- tools/ubuntu-app-watch.c	2015-02-25 22:50:24 +0000
+++ tools/ubuntu-app-watch.cpp	2016-02-08 22:18:15 +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,56 @@
  *     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::AppLaunch::Registry registry;
+
+    registry.appStarted.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                   std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance)
+                                {
+                                    std::cout << "Started: " << (std::string)app->appId() << std::endl;
+                                });
+    registry.appStopped.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                   std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance)
+                                {
+                                    std::cout << "Stopped: " << (std::string)app->appId() << std::endl;
+                                });
+    registry.appPaused.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                  std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance)
+                               {
+                                   std::cout << "Paused:  " << (std::string)app->appId() << std::endl;
+                               });
+    registry.appResumed.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                   std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance)
+                                {
+                                    std::cout << "Resumed: " << (std::string)app->appId() << std::endl;
+                                });
+    registry.appFailed.connect([](std::shared_ptr<Ubuntu::AppLaunch::Application> app,
+                                  std::shared_ptr<Ubuntu::AppLaunch::Application::Instance> instance,
+                                  Ubuntu::AppLaunch::Registry::FailureType type)
+                               {
+                                   std::cout << "Failed:  " << (std::string)app->appId();
+                                   switch (type)
+                                   {
+                                       case Ubuntu::AppLaunch::Registry::FailureType::CRASH:
+                                           std::cout << " (crash)";
+                                           break;
+                                       case Ubuntu::AppLaunch::Registry::FailureType::START_FAILURE:
+                                           std::cout << " (start failure)";
+                                           break;
+                                   }
+                                   std::cout << std::endl;
+                               });
+
+    std::signal(SIGTERM, [](int signal) -> void
+                         {
+                             retval.set_value(0);
+                         });
+    return retval.get_future().get();
 }