/* * Copyright 2013 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 * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program. If not, see . * * Authors: * Ted Gould */ #include "lomiri-app-launch.h" #include "lomiri-app-launch-trace.h" extern "C" { #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #include #pragma GCC diagnostic pop #include "utils.h" #include "ual-tracepoint.h" #include "proxy-socket-demangler.h" } /* C++ Interface */ #include "application.h" #include "appid.h" #include "helper-impl.h" #include "registry.h" #include "registry-impl.h" #include #include #include #include using namespace lomiri::util; /* Make a typed string vector out of a GStrv */ template static std::vector uriVector (const gchar * const * uris) { std::vector urivect; for (auto i = 0; uris != nullptr && uris[i] != nullptr; i++) { urivect.emplace_back(T::from_raw(uris[i])); } return urivect; } gboolean lomiri_app_launch_start_application (const gchar * appid, const gchar * const * uris) { try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); auto uriv = uriVector(uris); auto instance = app->launch(uriv); if (instance) { return TRUE; } else { return FALSE; } } catch (std::runtime_error &e) { g_warning("Unable to start app '%s': %s", appid, e.what()); return FALSE; } } gboolean lomiri_app_launch_start_application_test (const gchar * appid, const gchar * const * uris) { try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); auto uriv = uriVector(uris); auto instance = app->launchTest(uriv); if (instance) { return TRUE; } else { return FALSE; } } catch (std::runtime_error &e) { g_warning("Unable to start app '%s': %s", appid, e.what()); return FALSE; } } gboolean lomiri_app_launch_stop_application (const gchar * appid) { g_return_val_if_fail(appid != NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); auto instances = app->instances(); for (auto instance : instances) { instance->stop(); } return TRUE; } catch (std::runtime_error &e) { g_warning("Unable to stop app '%s': %s", appid, e.what()); return FALSE; } } gboolean lomiri_app_launch_pause_application (const gchar * appid) { try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); app->instances().at(0)->pause(); return TRUE; } catch (...) { return FALSE; } } gboolean lomiri_app_launch_resume_application (const gchar * appid) { try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); app->instances().at(0)->resume(); return TRUE; } catch (...) { return FALSE; } } /* Function to take a work function and have it execute on a given GMainContext */ static GSourceUPtr executeOnContext (const std::shared_ptr& context, std::function work) { if (!context) { work(); return nullptr; } auto heapWork = new std::function(work); auto source = unique_glib(g_idle_source_new()); g_source_set_callback(source.get(), [](gpointer data) { auto heapWork = static_cast*>(data); (*heapWork)(); return G_SOURCE_REMOVE; }, heapWork, [](gpointer data) { auto heapWork = static_cast*>(data); delete heapWork; }); g_source_attach(source.get(), context.get()); return source; } /** A handy helper function that is based of a function to get a signal and put it into a map. */ template &, const std::shared_ptr&>& (*getSignal)(const std::shared_ptr&)> static gboolean observer_add (LomiriAppLaunchAppObserver observer, gpointer user_data, std::map, core::ScopedConnection> &observers) { auto context = share_glib(g_main_context_ref_thread_default()); observers.emplace(std::make_pair( std::make_pair(observer, user_data), core::ScopedConnection( getSignal(lomiri::app_launch::Registry::getDefault()) .connect([context, observer, user_data](std::shared_ptr app, std::shared_ptr instance) { std::string appid = app->appId(); executeOnContext(context, [appid, observer, user_data]() { observer(appid.c_str(), user_data); }); }) ) )); return TRUE; } /** A handy helper to delete items from an observer map */ template static gboolean observer_delete (observertype observer, gpointer user_data, std::map, core::ScopedConnection> &observers) { auto iter = observers.find(std::make_pair(observer, user_data)); if (iter == observers.end()) { return FALSE; } observers.erase(iter); return TRUE; } /** Map of all the observers listening for app started */ static std::map, core::ScopedConnection> appStartedObservers; gboolean lomiri_app_launch_observer_add_app_started (LomiriAppLaunchAppObserver observer, gpointer user_data) { return observer_add<&lomiri::app_launch::Registry::appStarted>(observer, user_data, appStartedObservers); } gboolean lomiri_app_launch_observer_delete_app_started (LomiriAppLaunchAppObserver observer, gpointer user_data) { return observer_delete(observer, user_data, appStartedObservers); } /* Map of all the observers listening for app stopped */ static std::map, core::ScopedConnection> appStoppedObservers; gboolean lomiri_app_launch_observer_add_app_stop (LomiriAppLaunchAppObserver observer, gpointer user_data) { return observer_add<&lomiri::app_launch::Registry::appStopped>(observer, user_data, appStoppedObservers); } gboolean lomiri_app_launch_observer_delete_app_stop (LomiriAppLaunchAppObserver observer, gpointer user_data) { return observer_delete(observer, user_data, appStoppedObservers); } /** Class to implement the Registry::Manager interface for the C code using a GLib mainloop. */ class CManager : public lomiri::app_launch::Registry::Manager { public: CManager () { g_debug("Creating the CManager object"); } virtual ~CManager() { g_debug("Removing the shared the CManager object"); } void startingRequest(const std::shared_ptr& app, const std::shared_ptr& instance, std::function reply) override { requestImpl(app, instance, reply, "starting", startingList); } void focusRequest(const std::shared_ptr& app, const std::shared_ptr& instance, std::function reply) override { requestImpl(app, instance, reply, "focus", focusList); } void resumeRequest(const std::shared_ptr &app, const std::shared_ptr &instance, std::function reply) override { requestImpl(app, instance, reply, "resume", resumeList); } private: /** The Data that we track on an observer. It is the functions to call, the user data and the context to call it on. */ struct ObserverData { LomiriAppLaunchAppObserver observer; gpointer user_data; GMainContextSPtr context; std::list sources; /** Handy constructor to get the context in one place */ ObserverData(LomiriAppLaunchAppObserver obs, gpointer ud) : observer(obs) , user_data(ud) { context = share_glib(g_main_context_ref_thread_default()); } ~ObserverData() { /* * Cancel any work we've scheduled. This doesn't guarantee that * there won't be any work already running, if this is called from * a different thread than the context's. */ for (auto const &s: sources) { g_source_destroy(s.get()); } } }; std::mutex mutex; /**< Protect observer lists */ std::list focusList; /**< List of observers on the focus signal */ std::list resumeList; /**< List of observers on the resume signal */ std::list startingList; /**< List of observers on the starting signal */ /** Removes an observer from a specified list */ bool removeObserver (std::list &list, LomiriAppLaunchAppObserver observer, gpointer user_data) { std::lock_guard l(mutex); auto iter = std::find_if(list.begin(), list.end(), [observer, user_data](const ObserverData &data) { return data.observer == observer && data.user_data == user_data; }); if (iter == list.end()) { return false; } list.erase(iter); return true; } /** Implements a request for a specified list by calling each observer and then the reply */ inline void requestImpl ( const std::shared_ptr &app, const std::shared_ptr &instance, std::function reply, const std::string& name, std::list& list) { std::string sappid = app->appId(); g_debug("CManager %s: %s", name.c_str(), sappid.c_str()); { std::lock_guard l(mutex); for (auto &data : list) { auto source = executeOnContext(data.context, [sappid, &data]() { /* * Note: access list's member without a lock. We can't hold * it here because observer could call g_main_loop_run() * causing us to recurse to this function again. * * It should still be safe, as the registry thread only reads * the list, not modify. That is, until some prick calls * _observer_delete_*() from a different thread it's added. * In that case, we can't do anything as we didn't request * a GDestroyNotify function, and thus can't guarantee the * validity of data.user_data even if we keep data itself * alive. * * And even if some other thread deletes their observer, * std::list guarantee that it won't affect the validity * of not-removed element's reference. */ data.observer(sappid.c_str(), data.user_data); /* Remove the current GSource from the source list. */ auto cur_source = g_main_current_source(); auto source_iter = std::find_if(data.sources.begin(), data.sources.end(), [cur_source](const GSourceUPtr & list_source) { return list_source.get() == cur_source; }); if (source_iter != data.sources.end()) data.sources.erase(source_iter); }); if (source) data.sources.push_back(std::move(source)); } } reply(true); } public: void addFocus (LomiriAppLaunchAppObserver observer, gpointer user_data) { std::lock_guard l(mutex); focusList.emplace_back(observer, user_data); } void addResume (LomiriAppLaunchAppObserver observer, gpointer user_data) { std::lock_guard l(mutex); resumeList.emplace_back(observer, user_data); } void addStarting (LomiriAppLaunchAppObserver observer, gpointer user_data) { std::lock_guard l(mutex); startingList.emplace_back(observer, user_data); } bool deleteFocus (LomiriAppLaunchAppObserver observer, gpointer user_data) { return removeObserver(focusList, observer, user_data); } bool deleteResume (LomiriAppLaunchAppObserver observer, gpointer user_data) { return removeObserver(resumeList, observer, user_data); } bool deleteStarting (LomiriAppLaunchAppObserver observer, gpointer user_data) { return removeObserver(startingList, observer, user_data); } }; /** Weak pointer to the CManager if it is still in use. If it gets free'd by the registry we're okay with that. */ static std::weak_ptr cmanager; /** Function to create the CManager if it doesn't currently exist. Otherwise just return a lock to it */ static std::shared_ptr ensure_cmanager () { auto retval = cmanager.lock(); if (!retval) { retval = std::make_shared(); lomiri::app_launch::Registry::setManager(retval, lomiri::app_launch::Registry::getDefault()); cmanager = retval; } return retval; } gboolean lomiri_app_launch_observer_add_app_focus (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); manager->addFocus(observer, user_data); return TRUE; } gboolean lomiri_app_launch_observer_delete_app_focus (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); return manager->deleteFocus(observer, user_data) ? TRUE : FALSE; } gboolean lomiri_app_launch_observer_add_app_resume (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); manager->addResume(observer, user_data); return TRUE; } gboolean lomiri_app_launch_observer_delete_app_resume (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); return manager->deleteResume(observer, user_data) ? TRUE : FALSE; } gboolean lomiri_app_launch_observer_add_app_starting (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); lomiri::app_launch::Registry::Impl::watchingAppStarting(true); manager->addStarting(observer, user_data); return TRUE; } gboolean lomiri_app_launch_observer_delete_app_starting (LomiriAppLaunchAppObserver observer, gpointer user_data) { auto manager = ensure_cmanager(); lomiri::app_launch::Registry::Impl::watchingAppStarting(false); return manager->deleteStarting(observer, user_data) ? TRUE : FALSE; } /* Map of all the observers listening for app stopped */ static std::map, core::ScopedConnection> appFailedObservers; gboolean lomiri_app_launch_observer_add_app_failed (LomiriAppLaunchAppFailedObserver observer, gpointer user_data) { auto context = share_glib(g_main_context_ref_thread_default()); auto reg = lomiri::app_launch::Registry::getDefault(); appFailedObservers.emplace(std::make_pair( std::make_pair(observer, user_data), core::ScopedConnection( lomiri::app_launch::Registry::appFailed(reg).connect([context, observer, user_data](std::shared_ptr app, std::shared_ptr instance, lomiri::app_launch::Registry::FailureType type) { std::string appid = app->appId(); executeOnContext(context, [appid, type, observer, user_data]() { LomiriAppLaunchAppFailed ctype{LOMIRI_APP_LAUNCH_APP_FAILED_CRASH}; switch (type) { case lomiri::app_launch::Registry::FailureType::CRASH: ctype = LOMIRI_APP_LAUNCH_APP_FAILED_CRASH; break; case lomiri::app_launch::Registry::FailureType::START_FAILURE: ctype = LOMIRI_APP_LAUNCH_APP_FAILED_START_FAILURE; break; } observer(appid.c_str(), ctype, user_data); }); }) ) )); return TRUE; } gboolean lomiri_app_launch_observer_delete_app_failed (LomiriAppLaunchAppFailedObserver observer, gpointer user_data) { return observer_delete(observer, user_data, appFailedObservers); } /** Handy helper for pause and resume here */ template &, const std::shared_ptr&, const std::vector&>& (*getSignal)(const std::shared_ptr&)> static gboolean observer_add_pause (LomiriAppLaunchAppPausedResumedObserver observer, gpointer user_data, std::map, core::ScopedConnection> &observers) { auto context = share_glib(g_main_context_ref_thread_default()); observers.emplace(std::make_pair( std::make_pair(observer, user_data), core::ScopedConnection( getSignal(lomiri::app_launch::Registry::getDefault()) .connect([context, observer, user_data](std::shared_ptr app, std::shared_ptr instance, const std::vector &pids) { std::vector lpids = pids; lpids.emplace_back(0); std::string appid = app->appId(); executeOnContext(context, [appid, observer, user_data, lpids]() { observer(appid.c_str(), (int *)(lpids.data()), user_data); }); }) ) )); return TRUE; } static std::map, core::ScopedConnection> appPausedObservers; gboolean lomiri_app_launch_observer_add_app_paused (LomiriAppLaunchAppPausedResumedObserver observer, gpointer user_data) { return observer_add_pause<&lomiri::app_launch::Registry::appPaused>(observer, user_data, appPausedObservers); } gboolean lomiri_app_launch_observer_delete_app_paused (LomiriAppLaunchAppPausedResumedObserver observer, gpointer user_data) { return observer_delete(observer, user_data, appPausedObservers); } static std::map, core::ScopedConnection> appResumedObservers; gboolean lomiri_app_launch_observer_add_app_resumed (LomiriAppLaunchAppPausedResumedObserver observer, gpointer user_data) { return observer_add_pause<&lomiri::app_launch::Registry::appResumed>(observer, user_data, appResumedObservers); } gboolean lomiri_app_launch_observer_delete_app_resumed (LomiriAppLaunchAppPausedResumedObserver observer, gpointer user_data) { return observer_delete(observer, user_data, appResumedObservers); } gchar ** lomiri_app_launch_list_running_apps (void) { try { GArray * apps = g_array_new(TRUE, TRUE, sizeof(gchar *)); for (auto app : lomiri::app_launch::Registry::runningApps()) { std::string appid = app->appId(); g_debug("Adding AppID to list: %s", appid.c_str()); gchar * gappid = g_strdup(appid.c_str()); g_array_append_val(apps, gappid); } return (gchar **)g_array_free(apps, FALSE); } catch (const std::exception& e) { g_debug("Unable to list applications: %s", e.what()); return nullptr; } } GPid lomiri_app_launch_get_primary_pid (const gchar * appid) { g_return_val_if_fail(appid != NULL, 0); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); return app->instances().at(0)->primaryPid(); } catch (const std::exception& e) { g_debug("Unable to get primary pid: %s", e.what()); return 0; } } /* Get the PIDs for an AppID. If it's click or legacy single instance that's a simple call to the helper. But if it's not, we have to make a call for each instance of the app that we have running. */ GList * lomiri_app_launch_get_pids (const gchar * appid) { try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); auto pids = app->instances().at(0)->pids(); GList * retval = nullptr; for (auto pid : pids) { retval = g_list_prepend(retval, GINT_TO_POINTER(pid)); } return retval; } catch (...) { return nullptr; } } gboolean lomiri_app_launch_pid_in_app_id (GPid pid, const gchar * appid) { g_return_val_if_fail(appid != NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto app = lomiri::app_launch::Application::create(appId, registry); if (app->instances().at(0)->hasPid(pid)) { return TRUE; } else { return FALSE; } } catch (...) { return FALSE; } } gboolean lomiri_app_launch_app_id_parse (const gchar * appid, gchar ** package, gchar ** application, gchar ** version) { g_return_val_if_fail(appid != NULL, FALSE); try { auto appId = lomiri::app_launch::AppID::parse(appid); if (appId.empty()) { return FALSE; } if (package != nullptr) { *package = g_strdup(appId.package.value().c_str()); } if (application != nullptr) { *application = g_strdup(appId.appname.value().c_str()); } if (version != nullptr) { *version = g_strdup(appId.version.value().c_str()); } } catch (...) { return FALSE; } return TRUE; } /* Figure out whether we're a libertine container app or a click and then choose which function to use */ gchar * lomiri_app_launch_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver) { g_return_val_if_fail(pkg != NULL, NULL); std::string package{pkg}; std::string appname; std::string version; if (app != nullptr) { appname = app; } if (ver != nullptr) { version = ver; } auto appid = lomiri::app_launch::AppID::discover(package, appname, version); if (appid.empty()) { g_debug("Triplet lookup for '%s' '%s' '%s' returned empty", pkg, app, ver); return nullptr; } return g_strdup(std::string(appid).c_str()); } gboolean lomiri_app_launch_start_helper (const gchar * type, const gchar * appid, const gchar * const * uris) { g_return_val_if_fail(type != NULL, FALSE); g_return_val_if_fail(appid != NULL, FALSE); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); if (!helper->instances().empty()) { throw std::runtime_error{"Instance already exits"}; } auto uriv = uriVector(uris); auto inst = helper->launch(uriv); if (!inst) { throw std::runtime_error{"Empty instance"}; } return TRUE; } catch (std::runtime_error &e) { g_warning("Unable to launch helper of type '%s' id '%s': %s", type, appid, e.what()); return FALSE; } } gchar * lomiri_app_launch_start_multiple_helper (const gchar * type, const gchar * appid, const gchar * const * uris) { g_return_val_if_fail(type != NULL, NULL); g_return_val_if_fail(appid != NULL, NULL); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, NULL); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); auto uriv = uriVector(uris); auto inst = helper->launch(uriv); if (!inst) { throw std::runtime_error{"Empty instance"}; } return g_strdup(std::dynamic_pointer_cast(inst)->getInstanceId().c_str()); } catch (std::runtime_error &e) { g_warning("Unable to launch helper of type '%s' id '%s': %s", type, appid, e.what()); return nullptr; } } #ifdef LAL_USE_MIRCLIENT gchar * lomiri_app_launch_start_session_helper (const gchar * type, MirPromptSession * session, const gchar * appid, const gchar * const * uris) { g_return_val_if_fail(type != NULL, NULL); g_return_val_if_fail(session != NULL, NULL); g_return_val_if_fail(appid != NULL, NULL); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, NULL); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); auto uriv = uriVector(uris); auto inst = helper->launch(session, uriv); if (!inst) { throw std::runtime_error{"Empty instance"}; } return g_strdup(std::dynamic_pointer_cast(inst)->getInstanceId().c_str()); } catch (std::runtime_error &e) { g_warning("Unable to launch helper of type '%s' id '%s': %s", type, appid, e.what()); return nullptr; } } #endif gboolean lomiri_app_launch_stop_helper (const gchar * type, const gchar * appid) { g_return_val_if_fail(type != NULL, FALSE); g_return_val_if_fail(appid != NULL, FALSE); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); auto insts = helper->instances(); if (insts.empty()) { throw std::runtime_error{"No instances"}; } if (insts.size() > 1u) { throw std::runtime_error{"Expecting single instance but has multiple instances"}; } (*insts.begin())->stop(); return TRUE; } catch (std::runtime_error &e) { g_warning("Unable to stop helper of type '%s' id '%s': %s", type, appid, e.what()); return FALSE; } } gboolean lomiri_app_launch_stop_multiple_helper (const gchar * type, const gchar * appid, const gchar * instanceid) { g_return_val_if_fail(type != NULL, FALSE); g_return_val_if_fail(appid != NULL, FALSE); g_return_val_if_fail(instanceid != NULL, FALSE); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); auto inst = std::dynamic_pointer_cast(helper)->existingInstance(instanceid); if (!inst) { throw std::runtime_error{"No instances"}; } inst->stop(); return TRUE; } catch (std::runtime_error &e) { g_warning("Unable to stop helper of type '%s' id '%s' instance '%s': %s", type, appid, instanceid, e.what()); return FALSE; } } gchar ** lomiri_app_launch_list_helpers (const gchar * type) { g_return_val_if_fail(type != NULL, FALSE); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, FALSE); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto helpers = registry->runningHelpers(lomiri::app_launch::Helper::Type::from_raw(type)); auto array = g_array_new(TRUE, TRUE, sizeof(gchar *)); for (const auto &helper : helpers) { gchar * appid = g_strdup(std::string(helper->appId()).c_str()); g_array_append_val(array, appid); } return (gchar **)g_array_free(array, FALSE); } catch (std::runtime_error &e) { g_warning("Unable to get helpers for type '%s': %s", type, e.what()); return NULL; } } gchar ** lomiri_app_launch_list_helper_instances (const gchar * type, const gchar * appid) { g_return_val_if_fail(type != NULL, NULL); g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, NULL); g_return_val_if_fail(appid != NULL, NULL); try { auto registry = lomiri::app_launch::Registry::getDefault(); auto appId = lomiri::app_launch::AppID::find(appid); auto helper = lomiri::app_launch::Helper::create(lomiri::app_launch::Helper::Type::from_raw(type), appId, registry); auto insts = helper->instances(); auto array = g_array_new(TRUE, TRUE, sizeof(gchar *)); for (const auto &inst : insts) { auto internalinst = std::dynamic_pointer_cast(inst); auto cstr = g_strdup(internalinst->getInstanceId().c_str()); g_array_append_val(array, cstr); } return (gchar **)g_array_free(array, FALSE); } catch (std::runtime_error &e) { g_warning("Unable to get helper instances for '%s' of type '%s': %s", appid, type, e.what()); return NULL; } } /** A handy helper function that is based of a function to get a signal and put it into a map. */ template &, const std::shared_ptr&>& (*getSignal)(lomiri::app_launch::Helper::Type type, const std::shared_ptr&)> static gboolean helper_add (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data, std::map, core::ScopedConnection> &observers) { auto context = share_glib(g_main_context_ref_thread_default()); auto type = lomiri::app_launch::Helper::Type::from_raw(helper_type); observers.emplace(std::make_pair( std::make_tuple(observer, type.value(), user_data), core::ScopedConnection( getSignal(type, lomiri::app_launch::Registry::getDefault()) .connect([type, context, observer, user_data](std::shared_ptr app, std::shared_ptr instance) { auto internalinst = std::dynamic_pointer_cast(instance); std::string appid = app->appId(); std::string instanceid = internalinst->getInstanceId(); executeOnContext(context, [appid, instanceid, type, observer, user_data]() { observer(appid.c_str(), instanceid.c_str(), type.value().c_str(), user_data); }); }) ) )); return TRUE; } static gboolean helper_delete (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data, std::map, core::ScopedConnection> &observers) { auto type = lomiri::app_launch::Helper::Type::from_raw(helper_type); auto iter = observers.find(std::make_tuple(observer, type.value(), user_data)); if (iter == observers.end()) { return FALSE; } observers.erase(iter); return TRUE; } /** Map of all the observers listening for helper started */ static std::map, core::ScopedConnection> helperStartedObservers; static std::map, core::ScopedConnection> helperStoppedObservers; gboolean lomiri_app_launch_observer_add_helper_started (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data) { g_return_val_if_fail(observer != NULL, FALSE); g_return_val_if_fail(helper_type != NULL, FALSE); g_return_val_if_fail(g_strstr_len(helper_type, -1, ":") == NULL, FALSE); return helper_add<&lomiri::app_launch::Registry::helperStarted>(observer, helper_type, user_data, helperStartedObservers); } gboolean lomiri_app_launch_observer_add_helper_stop (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data) { g_return_val_if_fail(observer != NULL, FALSE); g_return_val_if_fail(helper_type != NULL, FALSE); g_return_val_if_fail(g_strstr_len(helper_type, -1, ":") == NULL, FALSE); return helper_add<&lomiri::app_launch::Registry::helperStopped>(observer, helper_type, user_data, helperStoppedObservers); } gboolean lomiri_app_launch_observer_delete_helper_started (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data) { g_return_val_if_fail(observer != NULL, FALSE); g_return_val_if_fail(helper_type != NULL, FALSE); g_return_val_if_fail(g_strstr_len(helper_type, -1, ":") == NULL, FALSE); return helper_delete(observer, helper_type, user_data, helperStartedObservers); } gboolean lomiri_app_launch_observer_delete_helper_stop (LomiriAppLaunchHelperObserver observer, const gchar * helper_type, gpointer user_data) { g_return_val_if_fail(observer != NULL, FALSE); g_return_val_if_fail(helper_type != NULL, FALSE); g_return_val_if_fail(g_strstr_len(helper_type, -1, ":") == NULL, FALSE); return helper_delete(observer, helper_type, user_data, helperStoppedObservers); } gboolean lomiri_app_launch_helper_set_exec (const gchar * execline, const gchar * directory) { g_return_val_if_fail(execline != NULL, FALSE); g_return_val_if_fail(execline[0] != '\0', FALSE); g_debug("Helper Set Exec: %s", execline); GError * error{nullptr}; gchar ** splitexec{nullptr}; if (!g_shell_parse_argv(execline, nullptr, &splitexec, &error) || error != nullptr) { g_warning("Unable to parse exec line '%s': %s", execline, error->message); g_error_free(error); return FALSE; } std::vector execvect; for (auto i = 0; splitexec[i] != nullptr; i++) { execvect.emplace_back(std::string{splitexec[i]}); } g_strfreev(splitexec); try { lomiri::app_launch::Helper::setExec(execvect); return TRUE; } catch (std::runtime_error &e) { g_warning("Unable to set exec line '%s': %s", execline, e.what()); return FALSE; } } gboolean lomiri_app_launch_application_info (const gchar * appid, gchar ** appdir, gchar ** appdesktop) { /* TODO: Remove next ABI break */ return FALSE; }