Merge lp:~ted/ubuntu-app-launch/snappy-backend-no-snap into lp:ubuntu-app-launch/16.10
- snappy-backend-no-snap
- Merge into trunk.16.10
| Status: | Merged |
|---|---|
| Approved by: | Ted Gould |
| Approved revision: | 371 |
| Merged at revision: | 252 |
| Proposed branch: | lp:~ted/ubuntu-app-launch/snappy-backend-no-snap |
| Merge into: | lp:ubuntu-app-launch/16.10 |
| Prerequisite: | lp:~ted/ubuntu-app-launch/snappy-backend-no-find-discover |
| Diff against target: |
1419 lines (+698/-265) 14 files modified
docs/index.rst (+11/-1) libubuntu-app-launch/app-info.c (+6/-128) libubuntu-app-launch/app-info.h (+0/-35) libubuntu-app-launch/appid.h (+61/-0) libubuntu-app-launch/application-impl-click.cpp (+109/-0) libubuntu-app-launch/application-impl-click.h (+27/-0) libubuntu-app-launch/application-impl-legacy.cpp (+102/-6) libubuntu-app-launch/application-impl-legacy.h (+26/-0) libubuntu-app-launch/application-impl-libertine.cpp (+97/-0) libubuntu-app-launch/application-impl-libertine.h (+30/-0) libubuntu-app-launch/application.cpp (+173/-51) libubuntu-app-launch/registry.cpp (+1/-1) libubuntu-app-launch/ubuntu-app-launch.cpp (+18/-11) tests/libual-cpp-test.cc (+37/-32) |
| To merge this branch: | bzr merge lp:~ted/ubuntu-app-launch/snappy-backend-no-snap |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Charles Kerr (community) | Approve | ||
| unity-api-1-bot | continuous-integration | Approve | |
|
Review via email:
|
|||
This proposal supersedes a proposal from 2016-08-03.
Commit message
Make find and discover use the application implementation functions.
Description of the change
This MR migrates the the find and discover functions over to the C++ interfaces, and importantly pushes the implementation of the various parts into the implementation classes. This was done so that we can easily add implementations (say for snappy) and have it work to find/discover AppIDs correctly.
| unity-api-1-bot (unity-api-1-bot) wrote : Posted in a previous version of this proposal | # |
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
FAILED: Continuous integration, rev:357
https:/
Executed test runs:
FAILURE: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
Click here to trigger a rebuild:
https:/
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
FAILED: Continuous integration, rev:358
https:/
Executed test runs:
FAILURE: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
Click here to trigger a rebuild:
https:/
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
FAILED: Continuous integration, rev:360
https:/
Executed test runs:
FAILURE: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
Click here to trigger a rebuild:
https:/
| Charles Kerr (charlesk) wrote : | # |
By some yardstick this was an easier review -- the code diff is smaller -- but I had a lot of questions about the type-specific methods.
Questions and comments inline
| Ted Gould (ted) wrote : | # |
On Wed, 2016-08-24 at 18:53 +0000, Charles Kerr wrote:
> By some yardstick this was an easier review -- the code diff is
> smaller -- but I had a lot of questions about the type-specific
> methods.
I think a lot of your questions came from not knowing the different
AppID schemes, which really means we didn't do a good job of
documenting that. So I tried to do that with narrative text on each of
the implementations: r363
> > + if (apps.size() == 0)
> apps is a std::list<> so size() has to walk the list.
>
> Since size is used twice in this function (here and in ONLY_LISTED
> below) better to store it in a temporary.
>
> In general, better to say "if (!foo.empty())" than "if (foo.size() ==
> 0)"
List size is constant since C++11: http://
tainer/list/size
But yes, empty would look better. r364
> > + switch (card)
> > + {
> > + case AppID::
> > + return *apps.begin();
> > + case AppID::
> out-of-scope for this review, but as an aside, what's the use case
> for LAST_LISTED?
Added for completeness, seemed odd to have first and only but not last.
I think almost everyone uses first.
> > + catch (std::runtime_
> > + {
> > + return false;
> does e.what need to be logged here? Looks like the answer is 'no' but
> wanted to be sure
No, it gets checked a fair amount and would be too chatty.
> +bool Legacy:
> > std::shared_
> > +{
> > + return package.
> (needinfo) Wait, whaaaat? Why would a function named verifyPackage()
> return true iff no package?
For Legacy apps the package field is empty.
> > + std::string desktop = std::string(
> redundant type information, suggest auto on lhs
> > >
> > + std::function<
> > [&desktop](const gchar* dir) {
> redundant type information, suggest auto on lhs
r365
> > +AppID::Version Legacy:
> > + const AppID::AppName& appname,
> > + const
> > std::shared_
> > +{
> > + return AppID::
> (needinfo) Why does findAppname() throw but findVersion() returns
> empty?
So my thought there was that if you're looking for the version, the
answer is always "", but we can't ever find an application, so that's
an error.
> > +/** Checks the AppID by making sure the version is "0.0" and then
> > + calling verifyAppname() to check the rest.
> (needinfo) Same "whaaaat" as above, I think I'm missing some context
> here. I don't understand what this is for, nor why a 0.0 test is
> useful
All Libertine applications have a version string of "0.0".
Using it as a test to reject things quickly. Since basically our
algorithm is "try all implementations" we end up with wanting to reject
as much as possible.
> > + catch (std::runtime_
> > + {
> > + return false;
> is this normal, or should e.what() be logged?
Normal.
> > + auto container =...
- 361. By Ted Gould
-
Bring in updates to no-find-discover branch
- 362. By Ted Gould
-
Fix abicheck
- 363. By Ted Gould
-
Write text explaining the app id schemes for the various backends
- 364. By Ted Gould
-
Use empty instead of checking the size
- 365. By Ted Gould
-
Going full auto
- 366. By Ted Gould
-
Removing a string cast
- 367. By Ted Gould
-
Spelling fix
- 368. By Ted Gould
-
Make sure we don't copy the tools structures
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
FAILED: Continuous integration, rev:368
https:/
Executed test runs:
FAILURE: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
FAILURE: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
FAILURE: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
FAILURE: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
| Charles Kerr (charlesk) wrote : | # |
Thanks for the changes, especially the extra explanations. :)
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
PASSED: Continuous integration, rev:369
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
PASSED: Continuous integration, rev:370
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
| unity-api-1-bot (unity-api-1-bot) wrote : | # |
PASSED: Continuous integration, rev:371
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
| Charles Kerr (charlesk) wrote : | # |
Reapprove to pick up r370
Preview Diff
| 1 | === modified file 'docs/index.rst' | |||
| 2 | --- docs/index.rst 2016-04-29 14:20:11 +0000 | |||
| 3 | +++ docs/index.rst 2016-09-06 16:14:41 +0000 | |||
| 4 | @@ -109,7 +109,7 @@ | |||
| 5 | 109 | Application Icon Finder | 109 | Application Icon Finder |
| 6 | 110 | ------------------------ | 110 | ------------------------ |
| 7 | 111 | 111 | ||
| 9 | 112 | .. doxygenclass:: ubuntu::app_launch::app_info::IconFinder | 112 | .. doxygenclass:: ubuntu::app_launch::IconFinder |
| 10 | 113 | :project: libubuntu-app-launch | 113 | :project: libubuntu-app-launch |
| 11 | 114 | :members: | 114 | :members: |
| 12 | 115 | :protected-members: | 115 | :protected-members: |
| 13 | @@ -146,6 +146,16 @@ | |||
| 14 | 146 | :private-members: | 146 | :private-members: |
| 15 | 147 | :undoc-members: | 147 | :undoc-members: |
| 16 | 148 | 148 | ||
| 17 | 149 | Upstart Instance | ||
| 18 | 150 | ---------------- | ||
| 19 | 151 | |||
| 20 | 152 | .. doxygenclass:: ubuntu::app_launch::app_impls::UpstartInstance | ||
| 21 | 153 | :project: libubuntu-app-launch | ||
| 22 | 154 | :members: | ||
| 23 | 155 | :protected-members: | ||
| 24 | 156 | :private-members: | ||
| 25 | 157 | :undoc-members: | ||
| 26 | 158 | |||
| 27 | 149 | Quality | 159 | Quality |
| 28 | 150 | ======= | 160 | ======= |
| 29 | 151 | 161 | ||
| 30 | 152 | 162 | ||
| 31 | === modified file 'libubuntu-app-launch/app-info.c' | |||
| 32 | --- libubuntu-app-launch/app-info.c 2016-09-06 16:14:40 +0000 | |||
| 33 | +++ libubuntu-app-launch/app-info.c 2016-09-06 16:14:41 +0000 | |||
| 34 | @@ -21,7 +21,9 @@ | |||
| 35 | 21 | #include <click.h> | 21 | #include <click.h> |
| 36 | 22 | 22 | ||
| 37 | 23 | #include "ubuntu-app-launch.h" | 23 | #include "ubuntu-app-launch.h" |
| 39 | 24 | #include "app-info.h" | 24 | |
| 40 | 25 | /* Prototypes */ | ||
| 41 | 26 | static gboolean app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop); | ||
| 42 | 25 | 27 | ||
| 43 | 26 | /* Try and get a manifest and do a couple sanity checks on it */ | 28 | /* Try and get a manifest and do a couple sanity checks on it */ |
| 44 | 27 | static JsonObject * | 29 | static JsonObject * |
| 45 | @@ -76,130 +78,6 @@ | |||
| 46 | 76 | return manifest; | 78 | return manifest; |
| 47 | 77 | } | 79 | } |
| 48 | 78 | 80 | ||
| 49 | 79 | /* Types of search we can do for an app name */ | ||
| 50 | 80 | enum _app_name_t { | ||
| 51 | 81 | APP_NAME_ONLY, | ||
| 52 | 82 | APP_NAME_FIRST, | ||
| 53 | 83 | APP_NAME_LAST | ||
| 54 | 84 | }; | ||
| 55 | 85 | typedef enum _app_name_t app_name_t; | ||
| 56 | 86 | |||
| 57 | 87 | /* Figure out the app name if it's one of the keywords */ | ||
| 58 | 88 | static const gchar * | ||
| 59 | 89 | manifest_app_name (JsonObject ** manifest, const gchar * pkg, const gchar * original_app) | ||
| 60 | 90 | { | ||
| 61 | 91 | app_name_t app_type = APP_NAME_FIRST; | ||
| 62 | 92 | |||
| 63 | 93 | if (original_app == NULL) { | ||
| 64 | 94 | /* first */ | ||
| 65 | 95 | } else if (g_strcmp0(original_app, "first-listed-app") == 0) { | ||
| 66 | 96 | /* first */ | ||
| 67 | 97 | } else if (g_strcmp0(original_app, "last-listed-app") == 0) { | ||
| 68 | 98 | app_type = APP_NAME_LAST; | ||
| 69 | 99 | } else if (g_strcmp0(original_app, "only-listed-app") == 0) { | ||
| 70 | 100 | app_type = APP_NAME_ONLY; | ||
| 71 | 101 | } else { | ||
| 72 | 102 | return original_app; | ||
| 73 | 103 | } | ||
| 74 | 104 | |||
| 75 | 105 | if (*manifest == NULL) { | ||
| 76 | 106 | *manifest = get_manifest(pkg, NULL); | ||
| 77 | 107 | } | ||
| 78 | 108 | |||
| 79 | 109 | JsonObject * hooks = json_object_get_object_member(*manifest, "hooks"); | ||
| 80 | 110 | |||
| 81 | 111 | if (hooks == NULL) { | ||
| 82 | 112 | return NULL; | ||
| 83 | 113 | } | ||
| 84 | 114 | |||
| 85 | 115 | GList * apps = json_object_get_members(hooks); | ||
| 86 | 116 | if (apps == NULL) { | ||
| 87 | 117 | return NULL; | ||
| 88 | 118 | } | ||
| 89 | 119 | |||
| 90 | 120 | const gchar * retapp = NULL; | ||
| 91 | 121 | |||
| 92 | 122 | switch (app_type) { | ||
| 93 | 123 | case APP_NAME_ONLY: | ||
| 94 | 124 | if (g_list_length(apps) == 1) { | ||
| 95 | 125 | retapp = (const gchar *)apps->data; | ||
| 96 | 126 | } | ||
| 97 | 127 | break; | ||
| 98 | 128 | case APP_NAME_FIRST: | ||
| 99 | 129 | retapp = (const gchar *)apps->data; | ||
| 100 | 130 | break; | ||
| 101 | 131 | case APP_NAME_LAST: | ||
| 102 | 132 | retapp = (const gchar *)(g_list_last(apps)->data); | ||
| 103 | 133 | break; | ||
| 104 | 134 | default: | ||
| 105 | 135 | break; | ||
| 106 | 136 | } | ||
| 107 | 137 | |||
| 108 | 138 | g_list_free(apps); | ||
| 109 | 139 | |||
| 110 | 140 | return retapp; | ||
| 111 | 141 | } | ||
| 112 | 142 | |||
| 113 | 143 | /* Figure out the app version using the manifest */ | ||
| 114 | 144 | static const gchar * | ||
| 115 | 145 | manifest_version (JsonObject ** manifest, const gchar * pkg, const gchar * original_ver) | ||
| 116 | 146 | { | ||
| 117 | 147 | if (original_ver != NULL && g_strcmp0(original_ver, "current-user-version") != 0) { | ||
| 118 | 148 | return original_ver; | ||
| 119 | 149 | } else { | ||
| 120 | 150 | if (*manifest == NULL) { | ||
| 121 | 151 | *manifest = get_manifest(pkg, NULL); | ||
| 122 | 152 | } | ||
| 123 | 153 | g_return_val_if_fail(*manifest != NULL, NULL); | ||
| 124 | 154 | |||
| 125 | 155 | return g_strdup(json_object_get_string_member(*manifest, "version")); | ||
| 126 | 156 | } | ||
| 127 | 157 | |||
| 128 | 158 | return NULL; | ||
| 129 | 159 | } | ||
| 130 | 160 | |||
| 131 | 161 | /* A click triplet can require using the Click DB and getting a | ||
| 132 | 162 | manifest. This code does that to look up the versions */ | ||
| 133 | 163 | gchar * | ||
| 134 | 164 | click_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver) | ||
| 135 | 165 | { | ||
| 136 | 166 | const gchar * version = NULL; | ||
| 137 | 167 | const gchar * application = NULL; | ||
| 138 | 168 | JsonObject * manifest = NULL; | ||
| 139 | 169 | |||
| 140 | 170 | version = manifest_version(&manifest, pkg, ver); | ||
| 141 | 171 | g_return_val_if_fail(version != NULL, NULL); | ||
| 142 | 172 | |||
| 143 | 173 | application = manifest_app_name(&manifest, pkg, app); | ||
| 144 | 174 | g_return_val_if_fail(application != NULL, NULL); | ||
| 145 | 175 | |||
| 146 | 176 | gchar * retval = g_strdup_printf("%s_%s_%s", pkg, application, version); | ||
| 147 | 177 | |||
| 148 | 178 | /* The object may hold allocation for some of our strings used above */ | ||
| 149 | 179 | if (manifest) | ||
| 150 | 180 | json_object_unref(manifest); | ||
| 151 | 181 | |||
| 152 | 182 | return retval; | ||
| 153 | 183 | } | ||
| 154 | 184 | |||
| 155 | 185 | /* Build an appid how we think it should exist and then make sure | ||
| 156 | 186 | we can find it. Then pull it together. */ | ||
| 157 | 187 | gchar * | ||
| 158 | 188 | libertine_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver) | ||
| 159 | 189 | { | ||
| 160 | 190 | if (app == NULL) { | ||
| 161 | 191 | return NULL; | ||
| 162 | 192 | } | ||
| 163 | 193 | |||
| 164 | 194 | gchar * synthappid = g_strdup_printf("%s_%s_0.0", pkg, app); | ||
| 165 | 195 | if (app_info_libertine(synthappid, NULL, NULL)) { | ||
| 166 | 196 | return synthappid; | ||
| 167 | 197 | } else { | ||
| 168 | 198 | g_free(synthappid); | ||
| 169 | 199 | return NULL; | ||
| 170 | 200 | } | ||
| 171 | 201 | } | ||
| 172 | 202 | |||
| 173 | 203 | /* Look to see if the app id results in a desktop file, if so, fill in the params */ | 81 | /* Look to see if the app id results in a desktop file, if so, fill in the params */ |
| 174 | 204 | static gboolean | 82 | static gboolean |
| 175 | 205 | evaluate_dir (const gchar * dir, const gchar * desktop, gchar ** appdir, gchar ** appdesktop) | 83 | evaluate_dir (const gchar * dir, const gchar * desktop, gchar ** appdir, gchar ** appdesktop) |
| 176 | @@ -224,7 +102,7 @@ | |||
| 177 | 224 | } | 102 | } |
| 178 | 225 | 103 | ||
| 179 | 226 | /* Handle the legacy case where we look through the data directories */ | 104 | /* Handle the legacy case where we look through the data directories */ |
| 181 | 227 | gboolean | 105 | static gboolean |
| 182 | 228 | app_info_legacy (const gchar * appid, gchar ** appdir, gchar ** appdesktop) | 106 | app_info_legacy (const gchar * appid, gchar ** appdir, gchar ** appdesktop) |
| 183 | 229 | { | 107 | { |
| 184 | 230 | gchar * desktop = g_strdup_printf("%s.desktop", appid); | 108 | gchar * desktop = g_strdup_printf("%s.desktop", appid); |
| 185 | @@ -248,7 +126,7 @@ | |||
| 186 | 248 | } | 126 | } |
| 187 | 249 | 127 | ||
| 188 | 250 | /* Handle the libertine case where we look in the container */ | 128 | /* Handle the libertine case where we look in the container */ |
| 190 | 251 | gboolean | 129 | static gboolean |
| 191 | 252 | app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop) | 130 | app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop) |
| 192 | 253 | { | 131 | { |
| 193 | 254 | char * container = NULL; | 132 | char * container = NULL; |
| 194 | @@ -301,7 +179,7 @@ | |||
| 195 | 301 | } | 179 | } |
| 196 | 302 | 180 | ||
| 197 | 303 | /* Get the information on where the desktop file is from libclick */ | 181 | /* Get the information on where the desktop file is from libclick */ |
| 199 | 304 | gboolean | 182 | static gboolean |
| 200 | 305 | app_info_click (const gchar * appid, gchar ** appdir, gchar ** appdesktop) | 183 | app_info_click (const gchar * appid, gchar ** appdir, gchar ** appdesktop) |
| 201 | 306 | { | 184 | { |
| 202 | 307 | gchar * package = NULL; | 185 | gchar * package = NULL; |
| 203 | 308 | 186 | ||
| 204 | === removed file 'libubuntu-app-launch/app-info.h' | |||
| 205 | --- libubuntu-app-launch/app-info.h 2016-06-07 01:49:09 +0000 | |||
| 206 | +++ libubuntu-app-launch/app-info.h 1970-01-01 00:00:00 +0000 | |||
| 207 | @@ -1,35 +0,0 @@ | |||
| 208 | 1 | /* | ||
| 209 | 2 | * Copyright © 2015 Canonical Ltd. | ||
| 210 | 3 | * | ||
| 211 | 4 | * This program is free software: you can redistribute it and/or modify it | ||
| 212 | 5 | * under the terms of the GNU General Public License version 3, as published | ||
| 213 | 6 | * by the Free Software Foundation. | ||
| 214 | 7 | * | ||
| 215 | 8 | * This program is distributed in the hope that it will be useful, but | ||
| 216 | 9 | * WITHOUT ANY WARRANTY; without even the implied warranties of | ||
| 217 | 10 | * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR | ||
| 218 | 11 | * PURPOSE. See the GNU General Public License for more details. | ||
| 219 | 12 | * | ||
| 220 | 13 | * You should have received a copy of the GNU General Public License along | ||
| 221 | 14 | * with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 222 | 15 | * | ||
| 223 | 16 | * Authors: | ||
| 224 | 17 | * Ted Gould <ted.gould@canonical.com> | ||
| 225 | 18 | */ | ||
| 226 | 19 | |||
| 227 | 20 | #pragma once | ||
| 228 | 21 | |||
| 229 | 22 | #include <gio/gio.h> | ||
| 230 | 23 | |||
| 231 | 24 | G_BEGIN_DECLS | ||
| 232 | 25 | |||
| 233 | 26 | gboolean app_info_legacy (const gchar * appid, gchar ** appdir, gchar ** appdesktop); | ||
| 234 | 27 | gboolean app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop); | ||
| 235 | 28 | gboolean app_info_click (const gchar * appid, gchar ** appdir, gchar ** appdesktop); | ||
| 236 | 29 | |||
| 237 | 30 | gchar * click_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver); | ||
| 238 | 31 | gchar * libertine_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver); | ||
| 239 | 32 | |||
| 240 | 33 | gboolean start_application_core (GDBusConnection * con, GCancellable * cancel, const gchar * appid, const gchar * const * uris, gboolean test); | ||
| 241 | 34 | |||
| 242 | 35 | G_END_DECLS | ||
| 243 | 36 | 0 | ||
| 244 | === modified file 'libubuntu-app-launch/appid.h' | |||
| 245 | --- libubuntu-app-launch/appid.h 2016-06-09 14:55:34 +0000 | |||
| 246 | +++ libubuntu-app-launch/appid.h 2016-09-06 16:14:41 +0000 | |||
| 247 | @@ -17,6 +17,7 @@ | |||
| 248 | 17 | * Ted Gould <ted.gould@canonical.com> | 17 | * Ted Gould <ted.gould@canonical.com> |
| 249 | 18 | */ | 18 | */ |
| 250 | 19 | 19 | ||
| 251 | 20 | #include <memory> | ||
| 252 | 20 | #include <string> | 21 | #include <string> |
| 253 | 21 | 22 | ||
| 254 | 22 | #include "type-tagger.h" | 23 | #include "type-tagger.h" |
| 255 | @@ -29,6 +30,8 @@ | |||
| 256 | 29 | namespace app_launch | 30 | namespace app_launch |
| 257 | 30 | { | 31 | { |
| 258 | 31 | 32 | ||
| 259 | 33 | class Registry; | ||
| 260 | 34 | |||
| 261 | 32 | /** \brief The set of information that is used to uniquely identify an | 35 | /** \brief The set of information that is used to uniquely identify an |
| 262 | 33 | application in Ubuntu. | 36 | application in Ubuntu. |
| 263 | 34 | 37 | ||
| 264 | @@ -104,9 +107,21 @@ | |||
| 265 | 104 | It can be used, but is slower than parse() if you've got well formed data | 107 | It can be used, but is slower than parse() if you've got well formed data |
| 266 | 105 | already. | 108 | already. |
| 267 | 106 | 109 | ||
| 268 | 110 | \note This will use the default registry instance, it is generally | ||
| 269 | 111 | recommended to have your own instead of using the default. | ||
| 270 | 112 | |||
| 271 | 107 | \param sappid String with the concatenated AppID | 113 | \param sappid String with the concatenated AppID |
| 272 | 108 | */ | 114 | */ |
| 273 | 109 | static AppID find(const std::string& sappid); | 115 | static AppID find(const std::string& sappid); |
| 274 | 116 | /** Find is a more tollerant version of parse(), it handles legacy applications, | ||
| 275 | 117 | short AppIDs ($package_$app) and other forms of that are in common usage. | ||
| 276 | 118 | It can be used, but is slower than parse() if you've got well formed data | ||
| 277 | 119 | already. | ||
| 278 | 120 | |||
| 279 | 121 | \param registry Registry instance to use for persistant connections | ||
| 280 | 122 | \param sappid String with the concatenated AppID | ||
| 281 | 123 | */ | ||
| 282 | 124 | static AppID find(const std::shared_ptr<Registry>& registry, const std::string& sappid); | ||
| 283 | 110 | /** Check to see whether a string is a valid AppID string | 125 | /** Check to see whether a string is a valid AppID string |
| 284 | 111 | 126 | ||
| 285 | 112 | \param sappid String with the concatenated AppID | 127 | \param sappid String with the concatenated AppID |
| 286 | @@ -130,6 +145,9 @@ | |||
| 287 | 130 | /** Find the AppID for an application where you only know the package | 145 | /** Find the AppID for an application where you only know the package |
| 288 | 131 | name. | 146 | name. |
| 289 | 132 | 147 | ||
| 290 | 148 | \note This will use the default registry instance, it is generally | ||
| 291 | 149 | recommended to have your own instead of using the default. | ||
| 292 | 150 | |||
| 293 | 133 | \param package Name of the package | 151 | \param package Name of the package |
| 294 | 134 | \param appwildcard Specification of how to search the manifest for apps | 152 | \param appwildcard Specification of how to search the manifest for apps |
| 295 | 135 | \param versionwildcard Specification of how to search for the version | 153 | \param versionwildcard Specification of how to search for the version |
| 296 | @@ -140,6 +158,9 @@ | |||
| 297 | 140 | /** Find the AppID for an application where you know the package | 158 | /** Find the AppID for an application where you know the package |
| 298 | 141 | name and application name. | 159 | name and application name. |
| 299 | 142 | 160 | ||
| 300 | 161 | \note This will use the default registry instance, it is generally | ||
| 301 | 162 | recommended to have your own instead of using the default. | ||
| 302 | 163 | |||
| 303 | 143 | \param package Name of the package | 164 | \param package Name of the package |
| 304 | 144 | \param appname Name of the application | 165 | \param appname Name of the application |
| 305 | 145 | \param versionwildcard Specification of how to search for the version | 166 | \param versionwildcard Specification of how to search for the version |
| 306 | @@ -149,15 +170,55 @@ | |||
| 307 | 149 | VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION); | 170 | VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION); |
| 308 | 150 | /** Create an AppID providing known strings of packages and names | 171 | /** Create an AppID providing known strings of packages and names |
| 309 | 151 | 172 | ||
| 310 | 173 | \note This will use the default registry instance, it is generally | ||
| 311 | 174 | recommended to have your own instead of using the default. | ||
| 312 | 175 | |||
| 313 | 152 | \param package Name of the package | 176 | \param package Name of the package |
| 314 | 153 | \param appname Name of the application | 177 | \param appname Name of the application |
| 315 | 154 | \param version Version of the package | 178 | \param version Version of the package |
| 316 | 155 | */ | 179 | */ |
| 317 | 156 | static AppID discover(const std::string& package, const std::string& appname, const std::string& version); | 180 | static AppID discover(const std::string& package, const std::string& appname, const std::string& version); |
| 318 | 181 | |||
| 319 | 182 | /** Find the AppID for an application where you only know the package | ||
| 320 | 183 | name. | ||
| 321 | 184 | |||
| 322 | 185 | \param registry Registry instance to use for persistant connections | ||
| 323 | 186 | \param package Name of the package | ||
| 324 | 187 | \param appwildcard Specification of how to search the manifest for apps | ||
| 325 | 188 | \param versionwildcard Specification of how to search for the version | ||
| 326 | 189 | */ | ||
| 327 | 190 | static AppID discover(const std::shared_ptr<Registry>& registry, | ||
| 328 | 191 | const std::string& package, | ||
| 329 | 192 | ApplicationWildcard appwildcard = ApplicationWildcard::FIRST_LISTED, | ||
| 330 | 193 | VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION); | ||
| 331 | 194 | /** Find the AppID for an application where you know the package | ||
| 332 | 195 | name and application name. | ||
| 333 | 196 | |||
| 334 | 197 | \param registry Registry instance to use for persistant connections | ||
| 335 | 198 | \param package Name of the package | ||
| 336 | 199 | \param appname Name of the application | ||
| 337 | 200 | \param versionwildcard Specification of how to search for the version | ||
| 338 | 201 | */ | ||
| 339 | 202 | static AppID discover(const std::shared_ptr<Registry>& registry, | ||
| 340 | 203 | const std::string& package, | ||
| 341 | 204 | const std::string& appname, | ||
| 342 | 205 | VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION); | ||
| 343 | 206 | /** Create an AppID providing known strings of packages and names | ||
| 344 | 207 | |||
| 345 | 208 | \param registry Registry instance to use for persistant connections | ||
| 346 | 209 | \param package Name of the package | ||
| 347 | 210 | \param appname Name of the application | ||
| 348 | 211 | \param version Version of the package | ||
| 349 | 212 | */ | ||
| 350 | 213 | static AppID discover(const std::shared_ptr<Registry>& registry, | ||
| 351 | 214 | const std::string& package, | ||
| 352 | 215 | const std::string& appname, | ||
| 353 | 216 | const std::string& version); | ||
| 354 | 157 | }; | 217 | }; |
| 355 | 158 | 218 | ||
| 356 | 159 | bool operator==(const AppID& a, const AppID& b); | 219 | bool operator==(const AppID& a, const AppID& b); |
| 357 | 160 | bool operator!=(const AppID& a, const AppID& b); | 220 | bool operator!=(const AppID& a, const AppID& b); |
| 358 | 221 | bool operator<(const AppID& a, const AppID& b); | ||
| 359 | 161 | 222 | ||
| 360 | 162 | } // namespace app_launch | 223 | } // namespace app_launch |
| 361 | 163 | } // namespace ubuntu | 224 | } // namespace ubuntu |
| 362 | 164 | 225 | ||
| 363 | === modified file 'libubuntu-app-launch/application-impl-click.cpp' | |||
| 364 | --- libubuntu-app-launch/application-impl-click.cpp 2016-09-06 16:14:40 +0000 | |||
| 365 | +++ libubuntu-app-launch/application-impl-click.cpp 2016-09-06 16:14:41 +0000 | |||
| 366 | @@ -58,6 +58,115 @@ | |||
| 367 | 58 | return _appid; | 58 | return _appid; |
| 368 | 59 | } | 59 | } |
| 369 | 60 | 60 | ||
| 370 | 61 | /** Check to see if this AppID has a desktop file that is in our link | ||
| 371 | 62 | farm built by Click. Click puts a symoblic link there for every | ||
| 372 | 63 | valid AppID. | ||
| 373 | 64 | |||
| 374 | 65 | \param appid Application ID to check | ||
| 375 | 66 | \param registry Persistent connections to use | ||
| 376 | 67 | */ | ||
| 377 | 68 | bool Click::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) | ||
| 378 | 69 | { | ||
| 379 | 70 | std::string appiddesktop = std::string(appid) + ".desktop"; | ||
| 380 | 71 | gchar* click_link = nullptr; | ||
| 381 | 72 | const gchar* link_farm_dir = g_getenv("UBUNTU_APP_LAUNCH_LINK_FARM"); | ||
| 382 | 73 | if (G_LIKELY(link_farm_dir == nullptr)) | ||
| 383 | 74 | { | ||
| 384 | 75 | click_link = | ||
| 385 | 76 | g_build_filename(g_get_user_cache_dir(), "ubuntu-app-launch", "desktop", appiddesktop.c_str(), NULL); | ||
| 386 | 77 | } | ||
| 387 | 78 | else | ||
| 388 | 79 | { | ||
| 389 | 80 | click_link = g_build_filename(link_farm_dir, appiddesktop.c_str(), NULL); | ||
| 390 | 81 | } | ||
| 391 | 82 | |||
| 392 | 83 | bool click = g_file_test(click_link, G_FILE_TEST_EXISTS); | ||
| 393 | 84 | g_free(click_link); | ||
| 394 | 85 | |||
| 395 | 86 | return click; | ||
| 396 | 87 | } | ||
| 397 | 88 | |||
| 398 | 89 | /** Tries to get the Click manifest for a package. If it can successfully | ||
| 399 | 90 | get the manifest returns true. | ||
| 400 | 91 | |||
| 401 | 92 | \param package Name of the package | ||
| 402 | 93 | \param registry Persistent connections to use | ||
| 403 | 94 | */ | ||
| 404 | 95 | bool Click::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) | ||
| 405 | 96 | { | ||
| 406 | 97 | return registry->impl->getClickManifest(package) != nullptr; | ||
| 407 | 98 | } | ||
| 408 | 99 | |||
| 409 | 100 | /** Verifies the applicaiton name by getting the list of applications | ||
| 410 | 101 | in the package manifest and seeing if the appname is in the list. | ||
| 411 | 102 | |||
| 412 | 103 | \param package Name of the package | ||
| 413 | 104 | \param appname Name of the application | ||
| 414 | 105 | \param registry Persistent connections to use | ||
| 415 | 106 | */ | ||
| 416 | 107 | bool Click::verifyAppname(const AppID::Package& package, | ||
| 417 | 108 | const AppID::AppName& appname, | ||
| 418 | 109 | const std::shared_ptr<Registry>& registry) | ||
| 419 | 110 | { | ||
| 420 | 111 | auto manifest = registry->impl->getClickManifest(package); | ||
| 421 | 112 | auto apps = manifestApps(manifest); | ||
| 422 | 113 | |||
| 423 | 114 | return std::find_if(apps.begin(), apps.end(), [&appname](const AppID::AppName& listApp) -> bool { | ||
| 424 | 115 | return appname.value() == listApp.value(); | ||
| 425 | 116 | }) != apps.end(); | ||
| 426 | 117 | } | ||
| 427 | 118 | |||
| 428 | 119 | /** Finds an application name based on a wildcard search. Gets the list | ||
| 429 | 120 | from the manifest, and then returns a value from that list. | ||
| 430 | 121 | |||
| 431 | 122 | \param package Name of the package | ||
| 432 | 123 | \param card Wildcard to search as | ||
| 433 | 124 | \param registry Persistent connections to use | ||
| 434 | 125 | */ | ||
| 435 | 126 | AppID::AppName Click::findAppname(const AppID::Package& package, | ||
| 436 | 127 | AppID::ApplicationWildcard card, | ||
| 437 | 128 | const std::shared_ptr<Registry>& registry) | ||
| 438 | 129 | { | ||
| 439 | 130 | auto manifest = registry->impl->getClickManifest(package); | ||
| 440 | 131 | auto apps = manifestApps(manifest); | ||
| 441 | 132 | |||
| 442 | 133 | if (apps.empty()) | ||
| 443 | 134 | { | ||
| 444 | 135 | throw std::runtime_error("No apps in package '" + package.value() + "' to find"); | ||
| 445 | 136 | } | ||
| 446 | 137 | |||
| 447 | 138 | switch (card) | ||
| 448 | 139 | { | ||
| 449 | 140 | case AppID::ApplicationWildcard::FIRST_LISTED: | ||
| 450 | 141 | return *apps.begin(); | ||
| 451 | 142 | case AppID::ApplicationWildcard::LAST_LISTED: | ||
| 452 | 143 | return *apps.rbegin(); | ||
| 453 | 144 | case AppID::ApplicationWildcard::ONLY_LISTED: | ||
| 454 | 145 | if (apps.size() != 1) | ||
| 455 | 146 | { | ||
| 456 | 147 | throw std::runtime_error("More than a single app in package '" + package.value() + | ||
| 457 | 148 | "' when requested to find only app"); | ||
| 458 | 149 | } | ||
| 459 | 150 | return *apps.begin(); | ||
| 460 | 151 | } | ||
| 461 | 152 | |||
| 462 | 153 | throw std::logic_error("Got a value of the app wildcard enum that can't exist"); | ||
| 463 | 154 | } | ||
| 464 | 155 | |||
| 465 | 156 | /** Find the version of a package that that is requested | ||
| 466 | 157 | |||
| 467 | 158 | \param package Name of the package | ||
| 468 | 159 | \param appname Name of the application (not used) | ||
| 469 | 160 | \param registry Persistent connections to use | ||
| 470 | 161 | */ | ||
| 471 | 162 | AppID::Version Click::findVersion(const AppID::Package& package, | ||
| 472 | 163 | const AppID::AppName& appname, | ||
| 473 | 164 | const std::shared_ptr<Registry>& registry) | ||
| 474 | 165 | { | ||
| 475 | 166 | auto manifest = registry->impl->getClickManifest(package); | ||
| 476 | 167 | return manifestVersion(manifest); | ||
| 477 | 168 | } | ||
| 478 | 169 | |||
| 479 | 61 | std::shared_ptr<Application::Info> Click::info() | 170 | std::shared_ptr<Application::Info> Click::info() |
| 480 | 62 | { | 171 | { |
| 481 | 63 | if (!_info) | 172 | if (!_info) |
| 482 | 64 | 173 | ||
| 483 | === modified file 'libubuntu-app-launch/application-impl-click.h' | |||
| 484 | --- libubuntu-app-launch/application-impl-click.h 2016-09-06 16:14:40 +0000 | |||
| 485 | +++ libubuntu-app-launch/application-impl-click.h 2016-09-06 16:14:41 +0000 | |||
| 486 | @@ -32,6 +32,20 @@ | |||
| 487 | 32 | namespace app_impls | 32 | namespace app_impls |
| 488 | 33 | { | 33 | { |
| 489 | 34 | 34 | ||
| 490 | 35 | /** Application Implmentation for Click packages. Click packages | ||
| 491 | 36 | are installed via the click tool and have information avaialable | ||
| 492 | 37 | on them via libclick. There is one version per-user on the system | ||
| 493 | 38 | and a Ubuntu App Launch hook makes a link to each of those versions | ||
| 494 | 39 | in the user's cache directory. Click ensures this is up-to-date. | ||
| 495 | 40 | |||
| 496 | 41 | Application IDs for Click packages are the standard it was built on. | ||
| 497 | 42 | Typically a package name is "$(application).$(developer id)" though | ||
| 498 | 43 | there isn't a requirement in the local Click tools to require that. The | ||
| 499 | 44 | appname element is gotten from the JSON manifest in the Click package and | ||
| 500 | 45 | should reference a desktop file. All Click packages also have a version. | ||
| 501 | 46 | |||
| 502 | 47 | More info: http://click.readthedocs.io/ | ||
| 503 | 48 | */ | ||
| 504 | 35 | class Click : public Base | 49 | class Click : public Base |
| 505 | 36 | { | 50 | { |
| 506 | 37 | public: | 51 | public: |
| 507 | @@ -49,6 +63,19 @@ | |||
| 508 | 49 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; | 63 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; |
| 509 | 50 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; | 64 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; |
| 510 | 51 | 65 | ||
| 511 | 66 | static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry); | ||
| 512 | 67 | |||
| 513 | 68 | static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry); | ||
| 514 | 69 | static bool verifyAppname(const AppID::Package& package, | ||
| 515 | 70 | const AppID::AppName& appname, | ||
| 516 | 71 | const std::shared_ptr<Registry>& registry); | ||
| 517 | 72 | static AppID::AppName findAppname(const AppID::Package& package, | ||
| 518 | 73 | AppID::ApplicationWildcard card, | ||
| 519 | 74 | const std::shared_ptr<Registry>& registry); | ||
| 520 | 75 | static AppID::Version findVersion(const AppID::Package& package, | ||
| 521 | 76 | const AppID::AppName& appname, | ||
| 522 | 77 | const std::shared_ptr<Registry>& registry); | ||
| 523 | 78 | |||
| 524 | 52 | private: | 79 | private: |
| 525 | 53 | AppID _appid; | 80 | AppID _appid; |
| 526 | 54 | 81 | ||
| 527 | 55 | 82 | ||
| 528 | === modified file 'libubuntu-app-launch/application-impl-legacy.cpp' | |||
| 529 | --- libubuntu-app-launch/application-impl-legacy.cpp 2016-09-06 16:14:40 +0000 | |||
| 530 | +++ libubuntu-app-launch/application-impl-legacy.cpp 2016-09-06 16:14:41 +0000 | |||
| 531 | @@ -57,7 +57,7 @@ | |||
| 532 | 57 | 57 | ||
| 533 | 58 | std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name) | 58 | std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name) |
| 534 | 59 | { | 59 | { |
| 536 | 60 | std::string desktopName = name.value() + ".desktop"; | 60 | auto desktopName = name.value() + ".desktop"; |
| 537 | 61 | std::string desktopPath; | 61 | std::string desktopPath; |
| 538 | 62 | auto keyfilecheck = [desktopName, &desktopPath](const std::string& dir) -> std::shared_ptr<GKeyFile> { | 62 | auto keyfilecheck = [desktopName, &desktopPath](const std::string& dir) -> std::shared_ptr<GKeyFile> { |
| 539 | 63 | auto fullname = g_build_filename(dir.c_str(), "applications", desktopName.c_str(), nullptr); | 63 | auto fullname = g_build_filename(dir.c_str(), "applications", desktopName.c_str(), nullptr); |
| 540 | @@ -99,14 +99,110 @@ | |||
| 541 | 99 | 99 | ||
| 542 | 100 | std::shared_ptr<Application::Info> Legacy::info() | 100 | std::shared_ptr<Application::Info> Legacy::info() |
| 543 | 101 | { | 101 | { |
| 544 | 102 | if (!appinfo_) | ||
| 545 | 103 | { | ||
| 546 | 104 | appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, app_info::DesktopFlags::ALLOW_NO_DISPLAY, | ||
| 547 | 105 | _registry); | ||
| 548 | 106 | } | ||
| 549 | 107 | return appinfo_; | 102 | return appinfo_; |
| 550 | 108 | } | 103 | } |
| 551 | 109 | 104 | ||
| 552 | 105 | /** Checks the AppID by ensuring the version and package are empty | ||
| 553 | 106 | then looks for the application. | ||
| 554 | 107 | |||
| 555 | 108 | \param appid AppID to check | ||
| 556 | 109 | \param registry persistent connections to use | ||
| 557 | 110 | */ | ||
| 558 | 111 | bool Legacy::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) | ||
| 559 | 112 | { | ||
| 560 | 113 | try | ||
| 561 | 114 | { | ||
| 562 | 115 | if (!appid.version.value().empty()) | ||
| 563 | 116 | { | ||
| 564 | 117 | return false; | ||
| 565 | 118 | } | ||
| 566 | 119 | |||
| 567 | 120 | return verifyAppname(appid.package, appid.appname, registry); | ||
| 568 | 121 | } | ||
| 569 | 122 | catch (std::runtime_error& e) | ||
| 570 | 123 | { | ||
| 571 | 124 | return false; | ||
| 572 | 125 | } | ||
| 573 | 126 | } | ||
| 574 | 127 | |||
| 575 | 128 | /** Ensure the package is empty | ||
| 576 | 129 | |||
| 577 | 130 | \param package Container name | ||
| 578 | 131 | \param registry persistent connections to use | ||
| 579 | 132 | */ | ||
| 580 | 133 | bool Legacy::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) | ||
| 581 | 134 | { | ||
| 582 | 135 | return package.value().empty(); | ||
| 583 | 136 | } | ||
| 584 | 137 | |||
| 585 | 138 | /** Looks for an application by looking through the system and user | ||
| 586 | 139 | application directories to find the desktop file. | ||
| 587 | 140 | |||
| 588 | 141 | \param package Container name | ||
| 589 | 142 | \param appname Application name to look for | ||
| 590 | 143 | \param registry persistent connections to use | ||
| 591 | 144 | */ | ||
| 592 | 145 | bool Legacy::verifyAppname(const AppID::Package& package, | ||
| 593 | 146 | const AppID::AppName& appname, | ||
| 594 | 147 | const std::shared_ptr<Registry>& registry) | ||
| 595 | 148 | { | ||
| 596 | 149 | if (!verifyPackage(package, registry)) | ||
| 597 | 150 | { | ||
| 598 | 151 | throw std::runtime_error{"Invalid Legacy package: " + std::string(package)}; | ||
| 599 | 152 | } | ||
| 600 | 153 | |||
| 601 | 154 | auto desktop = std::string(appname) + ".desktop"; | ||
| 602 | 155 | auto evaldir = [&desktop](const gchar* dir) -> bool { | ||
| 603 | 156 | char* fulldir = g_build_filename(dir, "applications", desktop.c_str(), nullptr); | ||
| 604 | 157 | gboolean found = g_file_test(fulldir, G_FILE_TEST_EXISTS); | ||
| 605 | 158 | g_free(fulldir); | ||
| 606 | 159 | return found == TRUE; | ||
| 607 | 160 | }; | ||
| 608 | 161 | |||
| 609 | 162 | if (evaldir(g_get_user_data_dir())) | ||
| 610 | 163 | { | ||
| 611 | 164 | return true; | ||
| 612 | 165 | } | ||
| 613 | 166 | |||
| 614 | 167 | const char* const* data_dirs = g_get_system_data_dirs(); | ||
| 615 | 168 | for (int i = 0; data_dirs[i] != nullptr; i++) | ||
| 616 | 169 | { | ||
| 617 | 170 | if (evaldir(data_dirs[i])) | ||
| 618 | 171 | { | ||
| 619 | 172 | return true; | ||
| 620 | 173 | } | ||
| 621 | 174 | } | ||
| 622 | 175 | |||
| 623 | 176 | return false; | ||
| 624 | 177 | } | ||
| 625 | 178 | |||
| 626 | 179 | /** We don't really have a way to implement this for Legacy, any | ||
| 627 | 180 | search wouldn't really make sense. We just throw an error. | ||
| 628 | 181 | |||
| 629 | 182 | \param package Container name | ||
| 630 | 183 | \param card Application search paths | ||
| 631 | 184 | \param registry persistent connections to use | ||
| 632 | 185 | */ | ||
| 633 | 186 | AppID::AppName Legacy::findAppname(const AppID::Package& package, | ||
| 634 | 187 | AppID::ApplicationWildcard card, | ||
| 635 | 188 | const std::shared_ptr<Registry>& registry) | ||
| 636 | 189 | { | ||
| 637 | 190 | throw std::runtime_error("Legacy apps can't be discovered by package"); | ||
| 638 | 191 | } | ||
| 639 | 192 | |||
| 640 | 193 | /** Function to return an empty string | ||
| 641 | 194 | |||
| 642 | 195 | \param package Container name (unused) | ||
| 643 | 196 | \param appname Application name (unused) | ||
| 644 | 197 | \param registry persistent connections to use (unused) | ||
| 645 | 198 | */ | ||
| 646 | 199 | AppID::Version Legacy::findVersion(const AppID::Package& package, | ||
| 647 | 200 | const AppID::AppName& appname, | ||
| 648 | 201 | const std::shared_ptr<Registry>& registry) | ||
| 649 | 202 | { | ||
| 650 | 203 | return AppID::Version::from_raw({}); | ||
| 651 | 204 | } | ||
| 652 | 205 | |||
| 653 | 110 | static const std::regex desktop_remover("^(.*)\\.desktop$"); | 206 | static const std::regex desktop_remover("^(.*)\\.desktop$"); |
| 654 | 111 | 207 | ||
| 655 | 112 | std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry) | 208 | std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry) |
| 656 | 113 | 209 | ||
| 657 | === modified file 'libubuntu-app-launch/application-impl-legacy.h' | |||
| 658 | --- libubuntu-app-launch/application-impl-legacy.h 2016-09-06 16:14:40 +0000 | |||
| 659 | +++ libubuntu-app-launch/application-impl-legacy.h 2016-09-06 16:14:41 +0000 | |||
| 660 | @@ -31,6 +31,19 @@ | |||
| 661 | 31 | namespace app_impls | 31 | namespace app_impls |
| 662 | 32 | { | 32 | { |
| 663 | 33 | 33 | ||
| 664 | 34 | /** Application Implementation for Legacy applications. These are applications | ||
| 665 | 35 | that are typically installed as Debian packages on the base system. The | ||
| 666 | 36 | standard place for them to put their desktop files is in /usr/share/applications | ||
| 667 | 37 | though other directories may be used by setting the appropriate XDG environment | ||
| 668 | 38 | variables. This implementation makes use of the GIO Desktop Appinfo functions | ||
| 669 | 39 | which do caching of those files to make access faster. | ||
| 670 | 40 | |||
| 671 | 41 | AppIDs for legacy applications only include the Appname variable. Both the package | ||
| 672 | 42 | and the version entries are empty strings. The appname variable is the filename | ||
| 673 | 43 | of the desktop file describing the application with the ".desktop" suffix. | ||
| 674 | 44 | |||
| 675 | 45 | More info: https://specifications.freedesktop.org/desktop-entry-spec/latest/ | ||
| 676 | 46 | */ | ||
| 677 | 34 | class Legacy : public Base | 47 | class Legacy : public Base |
| 678 | 35 | { | 48 | { |
| 679 | 36 | public: | 49 | public: |
| 680 | @@ -50,6 +63,19 @@ | |||
| 681 | 50 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; | 63 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; |
| 682 | 51 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; | 64 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; |
| 683 | 52 | 65 | ||
| 684 | 66 | static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry); | ||
| 685 | 67 | |||
| 686 | 68 | static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry); | ||
| 687 | 69 | static bool verifyAppname(const AppID::Package& package, | ||
| 688 | 70 | const AppID::AppName& appname, | ||
| 689 | 71 | const std::shared_ptr<Registry>& registry); | ||
| 690 | 72 | static AppID::AppName findAppname(const AppID::Package& package, | ||
| 691 | 73 | AppID::ApplicationWildcard card, | ||
| 692 | 74 | const std::shared_ptr<Registry>& registry); | ||
| 693 | 75 | static AppID::Version findVersion(const AppID::Package& package, | ||
| 694 | 76 | const AppID::AppName& appname, | ||
| 695 | 77 | const std::shared_ptr<Registry>& registry); | ||
| 696 | 78 | |||
| 697 | 53 | private: | 79 | private: |
| 698 | 54 | AppID::AppName _appname; | 80 | AppID::AppName _appname; |
| 699 | 55 | std::string _basedir; | 81 | std::string _basedir; |
| 700 | 56 | 82 | ||
| 701 | === modified file 'libubuntu-app-launch/application-impl-libertine.cpp' | |||
| 702 | --- libubuntu-app-launch/application-impl-libertine.cpp 2016-09-06 16:14:40 +0000 | |||
| 703 | +++ libubuntu-app-launch/application-impl-libertine.cpp 2016-09-06 16:14:41 +0000 | |||
| 704 | @@ -106,6 +106,103 @@ | |||
| 705 | 106 | return keyfile; | 106 | return keyfile; |
| 706 | 107 | } | 107 | } |
| 707 | 108 | 108 | ||
| 708 | 109 | /** Checks the AppID by making sure the version is "0.0" and then | ||
| 709 | 110 | calling verifyAppname() to check the rest. | ||
| 710 | 111 | |||
| 711 | 112 | \param appid AppID to check | ||
| 712 | 113 | \param registry persistent connections to use | ||
| 713 | 114 | */ | ||
| 714 | 115 | bool Libertine::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry) | ||
| 715 | 116 | { | ||
| 716 | 117 | try | ||
| 717 | 118 | { | ||
| 718 | 119 | if (appid.version.value() != "0.0") | ||
| 719 | 120 | { | ||
| 720 | 121 | return false; | ||
| 721 | 122 | } | ||
| 722 | 123 | |||
| 723 | 124 | return verifyAppname(appid.package, appid.appname, registry); | ||
| 724 | 125 | } | ||
| 725 | 126 | catch (std::runtime_error& e) | ||
| 726 | 127 | { | ||
| 727 | 128 | return false; | ||
| 728 | 129 | } | ||
| 729 | 130 | } | ||
| 730 | 131 | |||
| 731 | 132 | /** Verify a package name by getting the list of containers from | ||
| 732 | 133 | liblibertine and ensuring it is in that list. | ||
| 733 | 134 | |||
| 734 | 135 | \param package Container name | ||
| 735 | 136 | \param registry persistent connections to use | ||
| 736 | 137 | */ | ||
| 737 | 138 | bool Libertine::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry) | ||
| 738 | 139 | { | ||
| 739 | 140 | auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev); | ||
| 740 | 141 | |||
| 741 | 142 | for (int i = 0; containers.get()[i] != nullptr; i++) | ||
| 742 | 143 | { | ||
| 743 | 144 | auto container = containers.get()[i]; | ||
| 744 | 145 | if (container == package.value()) | ||
| 745 | 146 | { | ||
| 746 | 147 | return true; | ||
| 747 | 148 | } | ||
| 748 | 149 | } | ||
| 749 | 150 | |||
| 750 | 151 | return false; | ||
| 751 | 152 | } | ||
| 752 | 153 | |||
| 753 | 154 | /** Gets the list of applications from the container using liblibertine | ||
| 754 | 155 | and see if @appname is in that list. | ||
| 755 | 156 | |||
| 756 | 157 | \param package Container name | ||
| 757 | 158 | \param appname Application name to look for | ||
| 758 | 159 | \param registry persistent connections to use | ||
| 759 | 160 | */ | ||
| 760 | 161 | bool Libertine::verifyAppname(const AppID::Package& package, | ||
| 761 | 162 | const AppID::AppName& appname, | ||
| 762 | 163 | const std::shared_ptr<Registry>& registry) | ||
| 763 | 164 | { | ||
| 764 | 165 | auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(package.value().c_str()), g_strfreev); | ||
| 765 | 166 | |||
| 766 | 167 | for (int i = 0; apps.get()[i] != nullptr; i++) | ||
| 767 | 168 | { | ||
| 768 | 169 | auto appid = AppID::parse(apps.get()[i]); | ||
| 769 | 170 | if (appid.appname.value() == appname.value()) | ||
| 770 | 171 | { | ||
| 771 | 172 | return true; | ||
| 772 | 173 | } | ||
| 773 | 174 | } | ||
| 774 | 175 | |||
| 775 | 176 | return false; | ||
| 776 | 177 | } | ||
| 777 | 178 | |||
| 778 | 179 | /** We don't really have a way to implement this for Libertine, any | ||
| 779 | 180 | search wouldn't really make sense. We just throw an error. | ||
| 780 | 181 | |||
| 781 | 182 | \param package Container name | ||
| 782 | 183 | \param card Application search paths | ||
| 783 | 184 | \param registry persistent connections to use | ||
| 784 | 185 | */ | ||
| 785 | 186 | AppID::AppName Libertine::findAppname(const AppID::Package& package, | ||
| 786 | 187 | AppID::ApplicationWildcard card, | ||
| 787 | 188 | const std::shared_ptr<Registry>& registry) | ||
| 788 | 189 | { | ||
| 789 | 190 | throw std::runtime_error("Legacy apps can't be discovered by package"); | ||
| 790 | 191 | } | ||
| 791 | 192 | |||
| 792 | 193 | /** Function to return "0.0" | ||
| 793 | 194 | |||
| 794 | 195 | \param package Container name (unused) | ||
| 795 | 196 | \param appname Application name (unused) | ||
| 796 | 197 | \param registry persistent connections to use (unused) | ||
| 797 | 198 | */ | ||
| 798 | 199 | AppID::Version Libertine::findVersion(const AppID::Package& package, | ||
| 799 | 200 | const AppID::AppName& appname, | ||
| 800 | 201 | const std::shared_ptr<Registry>& registry) | ||
| 801 | 202 | { | ||
| 802 | 203 | return AppID::Version::from_raw("0.0"); | ||
| 803 | 204 | } | ||
| 804 | 205 | |||
| 805 | 109 | std::list<std::shared_ptr<Application>> Libertine::list(const std::shared_ptr<Registry>& registry) | 206 | std::list<std::shared_ptr<Application>> Libertine::list(const std::shared_ptr<Registry>& registry) |
| 806 | 110 | { | 207 | { |
| 807 | 111 | std::list<std::shared_ptr<Application>> applist; | 208 | std::list<std::shared_ptr<Application>> applist; |
| 808 | 112 | 209 | ||
| 809 | === modified file 'libubuntu-app-launch/application-impl-libertine.h' | |||
| 810 | --- libubuntu-app-launch/application-impl-libertine.h 2016-09-06 16:14:40 +0000 | |||
| 811 | +++ libubuntu-app-launch/application-impl-libertine.h 2016-09-06 16:14:41 +0000 | |||
| 812 | @@ -30,6 +30,23 @@ | |||
| 813 | 30 | namespace app_impls | 30 | namespace app_impls |
| 814 | 31 | { | 31 | { |
| 815 | 32 | 32 | ||
| 816 | 33 | /** Application Implmentation for the Libertine container system. Libertine | ||
| 817 | 34 | sets up containers that are read/write on a read only system, to all for | ||
| 818 | 35 | more dynamic packaging systems (like deb) to work. This provides some | ||
| 819 | 36 | compatibility for older applications or those who are only distributed in | ||
| 820 | 37 | packaging systems requiring full system access. | ||
| 821 | 38 | |||
| 822 | 39 | Application IDs for Libertine applications have the package field as the | ||
| 823 | 40 | name of the container. The appname is similar to that of the Legacy() implementation | ||
| 824 | 41 | as the filename of the desktop file defining the application without the | ||
| 825 | 42 | ".desktop" suffix. UAL has no way to know the version, so it is always hard | ||
| 826 | 43 | coded to "0.0". | ||
| 827 | 44 | |||
| 828 | 45 | Libertine applications always are setup with XMir and started using the | ||
| 829 | 46 | libertine-launch utility which configures the environment for the container. | ||
| 830 | 47 | |||
| 831 | 48 | More info: https://wiki.ubuntu.com/Touch/Libertine | ||
| 832 | 49 | */ | ||
| 833 | 33 | class Libertine : public Base | 50 | class Libertine : public Base |
| 834 | 34 | { | 51 | { |
| 835 | 35 | public: | 52 | public: |
| 836 | @@ -51,6 +68,19 @@ | |||
| 837 | 51 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; | 68 | std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override; |
| 838 | 52 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; | 69 | std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override; |
| 839 | 53 | 70 | ||
| 840 | 71 | static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry); | ||
| 841 | 72 | |||
| 842 | 73 | static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry); | ||
| 843 | 74 | static bool verifyAppname(const AppID::Package& package, | ||
| 844 | 75 | const AppID::AppName& appname, | ||
| 845 | 76 | const std::shared_ptr<Registry>& registry); | ||
| 846 | 77 | static AppID::AppName findAppname(const AppID::Package& package, | ||
| 847 | 78 | AppID::ApplicationWildcard card, | ||
| 848 | 79 | const std::shared_ptr<Registry>& registry); | ||
| 849 | 80 | static AppID::Version findVersion(const AppID::Package& package, | ||
| 850 | 81 | const AppID::AppName& appname, | ||
| 851 | 82 | const std::shared_ptr<Registry>& registry); | ||
| 852 | 83 | |||
| 853 | 54 | private: | 84 | private: |
| 854 | 55 | AppID::Package _container; | 85 | AppID::Package _container; |
| 855 | 56 | AppID::AppName _appname; | 86 | AppID::AppName _appname; |
| 856 | 57 | 87 | ||
| 857 | === modified file 'libubuntu-app-launch/application.cpp' | |||
| 858 | --- libubuntu-app-launch/application.cpp 2016-08-17 15:24:23 +0000 | |||
| 859 | +++ libubuntu-app-launch/application.cpp 2016-09-06 16:14:41 +0000 | |||
| 860 | @@ -18,7 +18,6 @@ | |||
| 861 | 18 | */ | 18 | */ |
| 862 | 19 | 19 | ||
| 863 | 20 | extern "C" { | 20 | extern "C" { |
| 864 | 21 | #include "app-info.h" | ||
| 865 | 22 | #include "ubuntu-app-launch.h" | 21 | #include "ubuntu-app-launch.h" |
| 866 | 23 | } | 22 | } |
| 867 | 24 | 23 | ||
| 868 | @@ -26,7 +25,9 @@ | |||
| 869 | 26 | #include "application-impl-legacy.h" | 25 | #include "application-impl-legacy.h" |
| 870 | 27 | #include "application-impl-libertine.h" | 26 | #include "application-impl-libertine.h" |
| 871 | 28 | #include "application.h" | 27 | #include "application.h" |
| 872 | 28 | #include "registry.h" | ||
| 873 | 29 | 29 | ||
| 874 | 30 | #include <functional> | ||
| 875 | 30 | #include <iostream> | 31 | #include <iostream> |
| 876 | 31 | #include <regex> | 32 | #include <regex> |
| 877 | 32 | 33 | ||
| 878 | @@ -42,22 +43,21 @@ | |||
| 879 | 42 | throw std::runtime_error("AppID is empty"); | 43 | throw std::runtime_error("AppID is empty"); |
| 880 | 43 | } | 44 | } |
| 881 | 44 | 45 | ||
| 884 | 45 | std::string sappid = appid; | 46 | if (app_impls::Click::hasAppId(appid, registry)) |
| 883 | 46 | if (app_info_click(sappid.c_str(), NULL, NULL)) | ||
| 885 | 47 | { | 47 | { |
| 886 | 48 | return std::make_shared<app_impls::Click>(appid, registry); | 48 | return std::make_shared<app_impls::Click>(appid, registry); |
| 887 | 49 | } | 49 | } |
| 889 | 50 | else if (app_info_libertine(sappid.c_str(), NULL, NULL)) | 50 | else if (app_impls::Libertine::hasAppId(appid, registry)) |
| 890 | 51 | { | 51 | { |
| 891 | 52 | return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry); | 52 | return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry); |
| 892 | 53 | } | 53 | } |
| 894 | 54 | else if (app_info_legacy(sappid.c_str(), NULL, NULL)) | 54 | else if (app_impls::Legacy::hasAppId(appid, registry)) |
| 895 | 55 | { | 55 | { |
| 896 | 56 | return std::make_shared<app_impls::Legacy>(appid.appname, registry); | 56 | return std::make_shared<app_impls::Legacy>(appid.appname, registry); |
| 897 | 57 | } | 57 | } |
| 898 | 58 | else | 58 | else |
| 899 | 59 | { | 59 | { |
| 901 | 60 | throw std::runtime_error("Invalid app ID: " + sappid); | 60 | throw std::runtime_error("Invalid app ID: " + std::string(appid)); |
| 902 | 61 | } | 61 | } |
| 903 | 62 | } | 62 | } |
| 904 | 63 | 63 | ||
| 905 | @@ -106,6 +106,12 @@ | |||
| 906 | 106 | 106 | ||
| 907 | 107 | AppID AppID::find(const std::string& sappid) | 107 | AppID AppID::find(const std::string& sappid) |
| 908 | 108 | { | 108 | { |
| 909 | 109 | auto registry = Registry::getDefault(); | ||
| 910 | 110 | return find(registry, sappid); | ||
| 911 | 111 | } | ||
| 912 | 112 | |||
| 913 | 113 | AppID AppID::find(const std::shared_ptr<Registry>& registry, const std::string& sappid) | ||
| 914 | 114 | { | ||
| 915 | 109 | std::smatch match; | 115 | std::smatch match; |
| 916 | 110 | 116 | ||
| 917 | 111 | if (std::regex_match(sappid, match, full_appid_regex)) | 117 | if (std::regex_match(sappid, match, full_appid_regex)) |
| 918 | @@ -115,7 +121,7 @@ | |||
| 919 | 115 | } | 121 | } |
| 920 | 116 | else if (std::regex_match(sappid, match, short_appid_regex)) | 122 | else if (std::regex_match(sappid, match, short_appid_regex)) |
| 921 | 117 | { | 123 | { |
| 923 | 118 | return discover(match[1].str(), match[2].str()); | 124 | return discover(registry, match[1].str(), match[2].str()); |
| 924 | 119 | } | 125 | } |
| 925 | 120 | else if (std::regex_match(sappid, match, legacy_appid_regex)) | 126 | else if (std::regex_match(sappid, match, legacy_appid_regex)) |
| 926 | 121 | { | 127 | { |
| 927 | @@ -156,67 +162,183 @@ | |||
| 928 | 156 | a.version.value() != b.version.value(); | 162 | a.version.value() != b.version.value(); |
| 929 | 157 | } | 163 | } |
| 930 | 158 | 164 | ||
| 931 | 165 | /** Convert each AppID to a string and then compare the strings */ | ||
| 932 | 166 | bool operator<(const AppID& a, const AppID& b) | ||
| 933 | 167 | { | ||
| 934 | 168 | return std::string(a) < std::string(b); | ||
| 935 | 169 | } | ||
| 936 | 170 | |||
| 937 | 159 | bool AppID::empty() const | 171 | bool AppID::empty() const |
| 938 | 160 | { | 172 | { |
| 939 | 161 | return package.value().empty() && appname.value().empty() && version.value().empty(); | 173 | return package.value().empty() && appname.value().empty() && version.value().empty(); |
| 940 | 162 | } | 174 | } |
| 941 | 163 | 175 | ||
| 966 | 164 | std::string app_wildcard(AppID::ApplicationWildcard card) | 176 | /** Basically we're making our own VTable of static functions. Static |
| 967 | 165 | { | 177 | functions don't go in the normal VTables, so we can't use our class |
| 968 | 166 | switch (card) | 178 | inheritance here to help. So we're just packing these puppies into |
| 969 | 167 | { | 179 | a data structure and iterating over it. */ |
| 970 | 168 | case AppID::ApplicationWildcard::FIRST_LISTED: | 180 | struct DiscoverTools |
| 971 | 169 | return "first-listed-app"; | 181 | { |
| 972 | 170 | case AppID::ApplicationWildcard::LAST_LISTED: | 182 | std::function<bool(const AppID::Package& package, const std::shared_ptr<Registry>& registry)> verifyPackage; |
| 973 | 171 | return "last-listed-app"; | 183 | std::function<bool( |
| 974 | 172 | case AppID::ApplicationWildcard::ONLY_LISTED: | 184 | const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)> |
| 975 | 173 | return "only-listed-app"; | 185 | verifyAppname; |
| 976 | 174 | } | 186 | std::function<AppID::AppName( |
| 977 | 175 | 187 | const AppID::Package& package, AppID::ApplicationWildcard card, const std::shared_ptr<Registry>& registry)> | |
| 978 | 176 | return ""; | 188 | findAppname; |
| 979 | 177 | } | 189 | std::function<AppID::Version( |
| 980 | 178 | 190 | const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)> | |
| 981 | 179 | std::string ver_wildcard(AppID::VersionWildcard card) | 191 | findVersion; |
| 982 | 180 | { | 192 | std::function<bool(const AppID& appid, const std::shared_ptr<Registry>& registry)> hasAppId; |
| 983 | 181 | switch (card) | 193 | }; |
| 984 | 182 | { | 194 | |
| 985 | 183 | case AppID::VersionWildcard::CURRENT_USER_VERSION: | 195 | /** The tools in order that they should be used */ |
| 986 | 184 | return "current-user-version"; | 196 | static const std::vector<DiscoverTools> discoverTools{ |
| 987 | 185 | } | 197 | /* Click */ |
| 988 | 186 | 198 | {app_impls::Click::verifyPackage, app_impls::Click::verifyAppname, app_impls::Click::findAppname, | |
| 989 | 187 | return ""; | 199 | app_impls::Click::findVersion, app_impls::Click::hasAppId}, |
| 990 | 200 | /* Libertine */ | ||
| 991 | 201 | {app_impls::Libertine::verifyPackage, app_impls::Libertine::verifyAppname, app_impls::Libertine::findAppname, | ||
| 992 | 202 | app_impls::Libertine::findVersion, app_impls::Libertine::hasAppId}, | ||
| 993 | 203 | /* Legacy */ | ||
| 994 | 204 | {app_impls::Legacy::verifyPackage, app_impls::Legacy::verifyAppname, app_impls::Legacy::findAppname, | ||
| 995 | 205 | app_impls::Legacy::findVersion, app_impls::Legacy::hasAppId}}; | ||
| 996 | 206 | |||
| 997 | 207 | AppID AppID::discover(const std::shared_ptr<Registry>& registry, | ||
| 998 | 208 | const std::string& package, | ||
| 999 | 209 | const std::string& appname, | ||
| 1000 | 210 | const std::string& version) | ||
| 1001 | 211 | { | ||
| 1002 | 212 | auto pkg = AppID::Package::from_raw(package); | ||
| 1003 | 213 | |||
| 1004 | 214 | for (const auto& tools : discoverTools) | ||
| 1005 | 215 | { | ||
| 1006 | 216 | /* Figure out which type we have */ | ||
| 1007 | 217 | try | ||
| 1008 | 218 | { | ||
| 1009 | 219 | if (tools.verifyPackage(pkg, registry)) | ||
| 1010 | 220 | { | ||
| 1011 | 221 | auto app = AppID::AppName::from_raw({}); | ||
| 1012 | 222 | |||
| 1013 | 223 | if (appname.empty() || appname == "first-listed-app") | ||
| 1014 | 224 | { | ||
| 1015 | 225 | app = tools.findAppname(pkg, ApplicationWildcard::FIRST_LISTED, registry); | ||
| 1016 | 226 | } | ||
| 1017 | 227 | else if (appname == "last-listed-app") | ||
| 1018 | 228 | { | ||
| 1019 | 229 | app = tools.findAppname(pkg, ApplicationWildcard::LAST_LISTED, registry); | ||
| 1020 | 230 | } | ||
| 1021 | 231 | else if (appname == "only-listed-app") | ||
| 1022 | 232 | { | ||
| 1023 | 233 | app = tools.findAppname(pkg, ApplicationWildcard::ONLY_LISTED, registry); | ||
| 1024 | 234 | } | ||
| 1025 | 235 | else | ||
| 1026 | 236 | { | ||
| 1027 | 237 | app = AppID::AppName::from_raw(appname); | ||
| 1028 | 238 | if (!tools.verifyAppname(pkg, app, registry)) | ||
| 1029 | 239 | { | ||
| 1030 | 240 | throw std::runtime_error("App name passed in is not valid for this package type"); | ||
| 1031 | 241 | } | ||
| 1032 | 242 | } | ||
| 1033 | 243 | |||
| 1034 | 244 | auto ver = AppID::Version::from_raw({}); | ||
| 1035 | 245 | if (version.empty() || version == "current-user-version") | ||
| 1036 | 246 | { | ||
| 1037 | 247 | ver = tools.findVersion(pkg, app, registry); | ||
| 1038 | 248 | } | ||
| 1039 | 249 | else | ||
| 1040 | 250 | { | ||
| 1041 | 251 | ver = AppID::Version::from_raw(version); | ||
| 1042 | 252 | if (!tools.hasAppId({pkg, app, ver}, registry)) | ||
| 1043 | 253 | { | ||
| 1044 | 254 | throw std::runtime_error("Invalid version passed for this package type"); | ||
| 1045 | 255 | } | ||
| 1046 | 256 | } | ||
| 1047 | 257 | |||
| 1048 | 258 | return AppID{pkg, app, ver}; | ||
| 1049 | 259 | } | ||
| 1050 | 260 | } | ||
| 1051 | 261 | catch (std::runtime_error& e) | ||
| 1052 | 262 | { | ||
| 1053 | 263 | continue; | ||
| 1054 | 264 | } | ||
| 1055 | 265 | } | ||
| 1056 | 266 | |||
| 1057 | 267 | return {}; | ||
| 1058 | 268 | } | ||
| 1059 | 269 | |||
| 1060 | 270 | AppID AppID::discover(const std::shared_ptr<Registry>& registry, | ||
| 1061 | 271 | const std::string& package, | ||
| 1062 | 272 | ApplicationWildcard appwildcard, | ||
| 1063 | 273 | VersionWildcard versionwildcard) | ||
| 1064 | 274 | { | ||
| 1065 | 275 | auto pkg = AppID::Package::from_raw(package); | ||
| 1066 | 276 | |||
| 1067 | 277 | for (const auto& tools : discoverTools) | ||
| 1068 | 278 | { | ||
| 1069 | 279 | try | ||
| 1070 | 280 | { | ||
| 1071 | 281 | if (tools.verifyPackage(pkg, registry)) | ||
| 1072 | 282 | { | ||
| 1073 | 283 | auto app = tools.findAppname(pkg, appwildcard, registry); | ||
| 1074 | 284 | auto ver = tools.findVersion(pkg, app, registry); | ||
| 1075 | 285 | return AppID{pkg, app, ver}; | ||
| 1076 | 286 | } | ||
| 1077 | 287 | } | ||
| 1078 | 288 | catch (std::runtime_error& e) | ||
| 1079 | 289 | { | ||
| 1080 | 290 | /* Normal, try another */ | ||
| 1081 | 291 | continue; | ||
| 1082 | 292 | } | ||
| 1083 | 293 | } | ||
| 1084 | 294 | |||
| 1085 | 295 | return {}; | ||
| 1086 | 296 | } | ||
| 1087 | 297 | |||
| 1088 | 298 | AppID AppID::discover(const std::shared_ptr<Registry>& registry, | ||
| 1089 | 299 | const std::string& package, | ||
| 1090 | 300 | const std::string& appname, | ||
| 1091 | 301 | VersionWildcard versionwildcard) | ||
| 1092 | 302 | { | ||
| 1093 | 303 | auto pkg = AppID::Package::from_raw(package); | ||
| 1094 | 304 | auto app = AppID::AppName::from_raw(appname); | ||
| 1095 | 305 | |||
| 1096 | 306 | for (const auto& tools : discoverTools) | ||
| 1097 | 307 | { | ||
| 1098 | 308 | try | ||
| 1099 | 309 | { | ||
| 1100 | 310 | if (tools.verifyPackage(pkg, registry) && tools.verifyAppname(pkg, app, registry)) | ||
| 1101 | 311 | { | ||
| 1102 | 312 | auto ver = tools.findVersion(pkg, app, registry); | ||
| 1103 | 313 | return AppID{pkg, app, ver}; | ||
| 1104 | 314 | } | ||
| 1105 | 315 | } | ||
| 1106 | 316 | catch (std::runtime_error& e) | ||
| 1107 | 317 | { | ||
| 1108 | 318 | /* Normal, try another */ | ||
| 1109 | 319 | continue; | ||
| 1110 | 320 | } | ||
| 1111 | 321 | } | ||
| 1112 | 322 | |||
| 1113 | 323 | return {}; | ||
| 1114 | 188 | } | 324 | } |
| 1115 | 189 | 325 | ||
| 1116 | 190 | AppID AppID::discover(const std::string& package, const std::string& appname, const std::string& version) | 326 | AppID AppID::discover(const std::string& package, const std::string& appname, const std::string& version) |
| 1117 | 191 | { | 327 | { |
| 1125 | 192 | auto cappid = ubuntu_app_launch_triplet_to_app_id(package.c_str(), appname.c_str(), version.c_str()); | 328 | auto registry = Registry::getDefault(); |
| 1126 | 193 | 329 | return discover(registry, package, appname, version); | |
| 1120 | 194 | auto appid = cappid != nullptr ? AppID::parse(cappid) : AppID::parse(""); | ||
| 1121 | 195 | |||
| 1122 | 196 | g_free(cappid); | ||
| 1123 | 197 | |||
| 1124 | 198 | return appid; | ||
| 1127 | 199 | } | 330 | } |
| 1128 | 200 | 331 | ||
| 1129 | 201 | AppID AppID::discover(const std::string& package, ApplicationWildcard appwildcard, VersionWildcard versionwildcard) | 332 | AppID AppID::discover(const std::string& package, ApplicationWildcard appwildcard, VersionWildcard versionwildcard) |
| 1130 | 202 | { | 333 | { |
| 1132 | 203 | return discover(package, app_wildcard(appwildcard), ver_wildcard(versionwildcard)); | 334 | auto registry = Registry::getDefault(); |
| 1133 | 335 | return discover(registry, package, appwildcard, versionwildcard); | ||
| 1134 | 204 | } | 336 | } |
| 1135 | 205 | 337 | ||
| 1136 | 206 | AppID AppID::discover(const std::string& package, const std::string& appname, VersionWildcard versionwildcard) | 338 | AppID AppID::discover(const std::string& package, const std::string& appname, VersionWildcard versionwildcard) |
| 1137 | 207 | { | 339 | { |
| 1150 | 208 | auto appid = discover(package, appname, ver_wildcard(versionwildcard)); | 340 | auto registry = Registry::getDefault(); |
| 1151 | 209 | 341 | return discover(registry, package, appname, versionwildcard); | |
| 1140 | 210 | if (appid.empty()) | ||
| 1141 | 211 | { | ||
| 1142 | 212 | /* If we weren't able to go that route, we can see if it's libertine */ | ||
| 1143 | 213 | if (app_info_libertine((package + "_" + appname + "_0.0").c_str(), nullptr, nullptr)) | ||
| 1144 | 214 | { | ||
| 1145 | 215 | appid = AppID(Package::from_raw(package), AppName::from_raw(appname), Version::from_raw("0.0")); | ||
| 1146 | 216 | } | ||
| 1147 | 217 | } | ||
| 1148 | 218 | |||
| 1149 | 219 | return appid; | ||
| 1152 | 220 | } | 342 | } |
| 1153 | 221 | 343 | ||
| 1154 | 222 | enum class oom::Score : std::int32_t | 344 | enum class oom::Score : std::int32_t |
| 1155 | 223 | 345 | ||
| 1156 | === modified file 'libubuntu-app-launch/registry.cpp' | |||
| 1157 | --- libubuntu-app-launch/registry.cpp 2016-08-17 15:24:23 +0000 | |||
| 1158 | +++ libubuntu-app-launch/registry.cpp 2016-09-06 16:14:41 +0000 | |||
| 1159 | @@ -91,7 +91,7 @@ | |||
| 1160 | 91 | std::list<std::shared_ptr<Application>> apps; | 91 | std::list<std::shared_ptr<Application>> apps; |
| 1161 | 92 | for (auto instance : instanceset) | 92 | for (auto instance : instanceset) |
| 1162 | 93 | { | 93 | { |
| 1164 | 94 | auto appid = AppID::find(instance); | 94 | auto appid = AppID::find(connection, instance); |
| 1165 | 95 | auto app = Application::create(appid, connection); | 95 | auto app = Application::create(appid, connection); |
| 1166 | 96 | apps.push_back(app); | 96 | apps.push_back(app); |
| 1167 | 97 | } | 97 | } |
| 1168 | 98 | 98 | ||
| 1169 | === modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp' | |||
| 1170 | --- libubuntu-app-launch/ubuntu-app-launch.cpp 2016-09-06 16:14:40 +0000 | |||
| 1171 | +++ libubuntu-app-launch/ubuntu-app-launch.cpp 2016-09-06 16:14:41 +0000 | |||
| 1172 | @@ -27,7 +27,6 @@ | |||
| 1173 | 27 | #include <errno.h> | 27 | #include <errno.h> |
| 1174 | 28 | #include <zeitgeist.h> | 28 | #include <zeitgeist.h> |
| 1175 | 29 | 29 | ||
| 1176 | 30 | #include "app-info.h" | ||
| 1177 | 31 | #include "ubuntu-app-launch-trace.h" | 30 | #include "ubuntu-app-launch-trace.h" |
| 1178 | 32 | #include "helpers.h" | 31 | #include "helpers.h" |
| 1179 | 33 | #include "ual-tracepoint.h" | 32 | #include "ual-tracepoint.h" |
| 1180 | @@ -948,16 +947,24 @@ | |||
| 1181 | 948 | { | 947 | { |
| 1182 | 949 | g_return_val_if_fail(pkg != NULL, NULL); | 948 | g_return_val_if_fail(pkg != NULL, NULL); |
| 1183 | 950 | 949 | ||
| 1194 | 951 | /* Check if is a libertine container */ | 950 | std::string package{pkg}; |
| 1195 | 952 | gchar * libertinepath = g_build_filename(g_get_user_cache_dir(), "libertine-container", pkg, NULL); | 951 | std::string appname; |
| 1196 | 953 | gboolean libcontainer = g_file_test(libertinepath, G_FILE_TEST_EXISTS); | 952 | std::string version; |
| 1197 | 954 | g_free(libertinepath); | 953 | |
| 1198 | 955 | 954 | if (app != nullptr) { | |
| 1199 | 956 | if (libcontainer) { | 955 | appname = app; |
| 1200 | 957 | return libertine_triplet_to_app_id(pkg, app, ver); | 956 | } |
| 1201 | 958 | } else { | 957 | |
| 1202 | 959 | return click_triplet_to_app_id(pkg, app, ver); | 958 | if (ver != nullptr) { |
| 1203 | 960 | } | 959 | version = ver; |
| 1204 | 960 | } | ||
| 1205 | 961 | |||
| 1206 | 962 | auto appid = ubuntu::app_launch::AppID::discover(package, appname, version); | ||
| 1207 | 963 | if (appid.empty()) { | ||
| 1208 | 964 | return nullptr; | ||
| 1209 | 965 | } | ||
| 1210 | 966 | |||
| 1211 | 967 | return g_strdup(std::string(appid).c_str()); | ||
| 1212 | 961 | } | 968 | } |
| 1213 | 962 | 969 | ||
| 1214 | 963 | /* Print an error if we couldn't start it */ | 970 | /* Print an error if we couldn't start it */ |
| 1215 | 964 | 971 | ||
| 1216 | === modified file 'tests/libual-cpp-test.cc' | |||
| 1217 | --- tests/libual-cpp-test.cc 2016-09-06 16:14:40 +0000 | |||
| 1218 | +++ tests/libual-cpp-test.cc 2016-09-06 16:14:41 +0000 | |||
| 1219 | @@ -22,6 +22,7 @@ | |||
| 1220 | 22 | #include <functional> | 22 | #include <functional> |
| 1221 | 23 | #include <future> | 23 | #include <future> |
| 1222 | 24 | #include <gio/gio.h> | 24 | #include <gio/gio.h> |
| 1223 | 25 | #include <glib/gstdio.h> | ||
| 1224 | 25 | #include <gtest/gtest.h> | 26 | #include <gtest/gtest.h> |
| 1225 | 26 | #include <libdbustest/dbus-test.h> | 27 | #include <libdbustest/dbus-test.h> |
| 1226 | 27 | #include <numeric> | 28 | #include <numeric> |
| 1227 | @@ -310,7 +311,7 @@ | |||
| 1228 | 310 | } | 311 | } |
| 1229 | 311 | }; | 312 | }; |
| 1230 | 312 | 313 | ||
| 1232 | 313 | TEST_F(LibUAL, StartApplication) | 314 | TEST_F(LibUAL, StartClickApplication) |
| 1233 | 314 | { | 315 | { |
| 1234 | 315 | DbusTestDbusMockObject* obj = | 316 | DbusTestDbusMockObject* obj = |
| 1235 | 316 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); | 317 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); |
| 1236 | @@ -367,7 +368,7 @@ | |||
| 1237 | 367 | return; | 368 | return; |
| 1238 | 368 | } | 369 | } |
| 1239 | 369 | 370 | ||
| 1241 | 370 | TEST_F(LibUAL, StartApplicationTest) | 371 | TEST_F(LibUAL, StartClickApplicationTest) |
| 1242 | 371 | { | 372 | { |
| 1243 | 372 | DbusTestDbusMockObject* obj = | 373 | DbusTestDbusMockObject* obj = |
| 1244 | 373 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); | 374 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); |
| 1245 | @@ -395,7 +396,7 @@ | |||
| 1246 | 395 | g_variant_unref(env); | 396 | g_variant_unref(env); |
| 1247 | 396 | } | 397 | } |
| 1248 | 397 | 398 | ||
| 1250 | 398 | TEST_F(LibUAL, StopApplication) | 399 | TEST_F(LibUAL, StopClickApplication) |
| 1251 | 399 | { | 400 | { |
| 1252 | 400 | DbusTestDbusMockObject* obj = | 401 | DbusTestDbusMockObject* obj = |
| 1253 | 401 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); | 402 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL); |
| 1254 | @@ -424,7 +425,7 @@ | |||
| 1255 | 424 | std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-click-com.test.good_application_1.2.3.log"), | 425 | std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-click-com.test.good_application_1.2.3.log"), |
| 1256 | 425 | app->instances()[0]->logPath()); | 426 | app->instances()[0]->logPath()); |
| 1257 | 426 | 427 | ||
| 1259 | 427 | appid = ubuntu::app_launch::AppID::find("single"); | 428 | appid = ubuntu::app_launch::AppID::find(registry, "single"); |
| 1260 | 428 | app = ubuntu::app_launch::Application::create(appid, registry); | 429 | app = ubuntu::app_launch::Application::create(appid, registry); |
| 1261 | 429 | 430 | ||
| 1262 | 430 | ASSERT_LT(0, app->instances().size()); | 431 | ASSERT_LT(0, app->instances().size()); |
| 1263 | @@ -432,7 +433,7 @@ | |||
| 1264 | 432 | EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-single-.log"), | 433 | EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-single-.log"), |
| 1265 | 433 | app->instances()[0]->logPath()); | 434 | app->instances()[0]->logPath()); |
| 1266 | 434 | 435 | ||
| 1268 | 435 | appid = ubuntu::app_launch::AppID::find("multiple"); | 436 | appid = ubuntu::app_launch::AppID::find(registry, "multiple"); |
| 1269 | 436 | app = ubuntu::app_launch::Application::create(appid, registry); | 437 | app = ubuntu::app_launch::Application::create(appid, registry); |
| 1270 | 437 | 438 | ||
| 1271 | 438 | EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-multiple-2342345.log"), | 439 | EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-multiple-2342345.log"), |
| 1272 | @@ -454,9 +455,10 @@ | |||
| 1273 | 454 | EXPECT_TRUE(app->instances()[0]->hasPid(300)); | 455 | EXPECT_TRUE(app->instances()[0]->hasPid(300)); |
| 1274 | 455 | 456 | ||
| 1275 | 456 | /* Check primary pid, which comes from Upstart */ | 457 | /* Check primary pid, which comes from Upstart */ |
| 1276 | 458 | EXPECT_TRUE(app->instances()[0]->isRunning()); | ||
| 1277 | 457 | EXPECT_EQ(getpid(), app->instances()[0]->primaryPid()); | 459 | EXPECT_EQ(getpid(), app->instances()[0]->primaryPid()); |
| 1278 | 458 | 460 | ||
| 1280 | 459 | auto multiappid = ubuntu::app_launch::AppID::find("multiple"); | 461 | auto multiappid = ubuntu::app_launch::AppID::find(registry, "multiple"); |
| 1281 | 460 | auto multiapp = ubuntu::app_launch::Application::create(multiappid, registry); | 462 | auto multiapp = ubuntu::app_launch::Application::create(multiappid, registry); |
| 1282 | 461 | auto instances = multiapp->instances(); | 463 | auto instances = multiapp->instances(); |
| 1283 | 462 | ASSERT_LT(0, instances.size()); | 464 | ASSERT_LT(0, instances.size()); |
| 1284 | @@ -488,7 +490,7 @@ | |||
| 1285 | 488 | ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(cgmock, cgobject, NULL)); | 490 | ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(cgmock, cgobject, NULL)); |
| 1286 | 489 | 491 | ||
| 1287 | 490 | /* Legacy Single Instance */ | 492 | /* Legacy Single Instance */ |
| 1289 | 491 | auto singleappid = ubuntu::app_launch::AppID::find("single"); | 493 | auto singleappid = ubuntu::app_launch::AppID::find(registry, "single"); |
| 1290 | 492 | auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry); | 494 | auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry); |
| 1291 | 493 | 495 | ||
| 1292 | 494 | ASSERT_LT(0, singleapp->instances().size()); | 496 | ASSERT_LT(0, singleapp->instances().size()); |
| 1293 | @@ -517,50 +519,53 @@ | |||
| 1294 | 517 | 519 | ||
| 1295 | 518 | /* Test with current-user-version, should return the version in the manifest */ | 520 | /* Test with current-user-version, should return the version in the manifest */ |
| 1296 | 519 | EXPECT_EQ("com.test.good_application_1.2.3", | 521 | EXPECT_EQ("com.test.good_application_1.2.3", |
| 1298 | 520 | (std::string)ubuntu::app_launch::AppID::discover("com.test.good", "application")); | 522 | (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "application")); |
| 1299 | 521 | 523 | ||
| 1300 | 522 | /* Test with version specified, shouldn't even read the manifest */ | 524 | /* Test with version specified, shouldn't even read the manifest */ |
| 1301 | 523 | EXPECT_EQ("com.test.good_application_1.2.4", | 525 | EXPECT_EQ("com.test.good_application_1.2.4", |
| 1303 | 524 | (std::string)ubuntu::app_launch::AppID::discover("com.test.good", "application", "1.2.4")); | 526 | (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "application", "1.2.4")); |
| 1304 | 525 | 527 | ||
| 1305 | 526 | /* Test with out a version or app, should return the version in the manifest */ | 528 | /* Test with out a version or app, should return the version in the manifest */ |
| 1308 | 527 | EXPECT_EQ("com.test.good_application_1.2.3", (std::string)ubuntu::app_launch::AppID::discover( | 529 | EXPECT_EQ("com.test.good_application_1.2.3", |
| 1309 | 528 | "com.test.good", "first-listed-app", "current-user-version")); | 530 | (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "first-listed-app", |
| 1310 | 531 | "current-user-version")); | ||
| 1311 | 529 | 532 | ||
| 1312 | 530 | /* Make sure we can select the app from a list correctly */ | 533 | /* Make sure we can select the app from a list correctly */ |
| 1313 | 531 | EXPECT_EQ("com.test.multiple_first_1.2.3", | 534 | EXPECT_EQ("com.test.multiple_first_1.2.3", |
| 1314 | 532 | (std::string)ubuntu::app_launch::AppID::discover( | 535 | (std::string)ubuntu::app_launch::AppID::discover( |
| 1317 | 533 | "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::FIRST_LISTED)); | 536 | registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::FIRST_LISTED)); |
| 1318 | 534 | EXPECT_EQ("com.test.multiple_first_1.2.3", (std::string)ubuntu::app_launch::AppID::discover("com.test.multiple")); | 537 | EXPECT_EQ("com.test.multiple_first_1.2.3", |
| 1319 | 538 | (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.multiple")); | ||
| 1320 | 535 | EXPECT_EQ("com.test.multiple_fifth_1.2.3", | 539 | EXPECT_EQ("com.test.multiple_fifth_1.2.3", |
| 1321 | 536 | (std::string)ubuntu::app_launch::AppID::discover( | 540 | (std::string)ubuntu::app_launch::AppID::discover( |
| 1323 | 537 | "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::LAST_LISTED)); | 541 | registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::LAST_LISTED)); |
| 1324 | 538 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover( | 542 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover( |
| 1326 | 539 | "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED)); | 543 | registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED)); |
| 1327 | 540 | EXPECT_EQ("com.test.good_application_1.2.3", | 544 | EXPECT_EQ("com.test.good_application_1.2.3", |
| 1328 | 541 | (std::string)ubuntu::app_launch::AppID::discover( | 545 | (std::string)ubuntu::app_launch::AppID::discover( |
| 1330 | 542 | "com.test.good", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED)); | 546 | registry, "com.test.good", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED)); |
| 1331 | 543 | 547 | ||
| 1332 | 544 | /* A bunch that should be NULL */ | 548 | /* A bunch that should be NULL */ |
| 1337 | 545 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-hooks")); | 549 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-hooks")); |
| 1338 | 546 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-json")); | 550 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-json")); |
| 1339 | 547 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-object")); | 551 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-object")); |
| 1340 | 548 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-version")); | 552 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-version")); |
| 1341 | 549 | 553 | ||
| 1342 | 550 | /* Libertine tests */ | 554 | /* Libertine tests */ |
| 1346 | 551 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("container-name")); | 555 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name")); |
| 1347 | 552 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("container-name", "not-exist")); | 556 | EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "not-exist")); |
| 1348 | 553 | EXPECT_EQ("container-name_test_0.0", (std::string)ubuntu::app_launch::AppID::discover("container-name", "test")); | 557 | EXPECT_EQ("container-name_test_0.0", |
| 1349 | 558 | (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "test")); | ||
| 1350 | 554 | EXPECT_EQ("container-name_user-app_0.0", | 559 | EXPECT_EQ("container-name_user-app_0.0", |
| 1352 | 555 | (std::string)ubuntu::app_launch::AppID::discover("container-name", "user-app")); | 560 | (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "user-app")); |
| 1353 | 556 | } | 561 | } |
| 1354 | 557 | 562 | ||
| 1355 | 558 | TEST_F(LibUAL, AppIdParse) | 563 | TEST_F(LibUAL, AppIdParse) |
| 1356 | 559 | { | 564 | { |
| 1357 | 560 | EXPECT_FALSE(ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123").empty()); | 565 | EXPECT_FALSE(ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123").empty()); |
| 1359 | 561 | EXPECT_FALSE(ubuntu::app_launch::AppID::find("inkscape").empty()); | 566 | EXPECT_FALSE(ubuntu::app_launch::AppID::find(registry, "inkscape").empty()); |
| 1360 | 562 | EXPECT_FALSE(ubuntu::app_launch::AppID::parse("chatter.robert-ancell_chatter_2").empty()); | 567 | EXPECT_FALSE(ubuntu::app_launch::AppID::parse("chatter.robert-ancell_chatter_2").empty()); |
| 1362 | 563 | EXPECT_FALSE(ubuntu::app_launch::AppID::find("chatter.robert-ancell_chatter").empty()); | 568 | EXPECT_FALSE(ubuntu::app_launch::AppID::find(registry, "chatter.robert-ancell_chatter").empty()); |
| 1363 | 564 | 569 | ||
| 1364 | 565 | auto id = ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123"); | 570 | auto id = ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123"); |
| 1365 | 566 | 571 | ||
| 1366 | @@ -887,7 +892,7 @@ | |||
| 1367 | 887 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL); | 892 | dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL); |
| 1368 | 888 | 893 | ||
| 1369 | 889 | /* Check for a single-instance app */ | 894 | /* Check for a single-instance app */ |
| 1371 | 890 | auto singleappid = ubuntu::app_launch::AppID::find("single"); | 895 | auto singleappid = ubuntu::app_launch::AppID::find(registry, "single"); |
| 1372 | 891 | auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry); | 896 | auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry); |
| 1373 | 892 | 897 | ||
| 1374 | 893 | singleapp->launch(); | 898 | singleapp->launch(); |
| 1375 | @@ -912,7 +917,7 @@ | |||
| 1376 | 912 | ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL)); | 917 | ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL)); |
| 1377 | 913 | 918 | ||
| 1378 | 914 | /* Check for a multi-instance app */ | 919 | /* Check for a multi-instance app */ |
| 1380 | 915 | auto multipleappid = ubuntu::app_launch::AppID::find("multiple"); | 920 | auto multipleappid = ubuntu::app_launch::AppID::find(registry, "multiple"); |
| 1381 | 916 | auto multipleapp = ubuntu::app_launch::Application::create(multipleappid, registry); | 921 | auto multipleapp = ubuntu::app_launch::Application::create(multipleappid, registry); |
| 1382 | 917 | 922 | ||
| 1383 | 918 | multipleapp->launch(); | 923 | multipleapp->launch(); |
| 1384 | @@ -1382,7 +1387,7 @@ | |||
| 1385 | 1382 | signal_increment, &resumed_count, nullptr); | 1387 | signal_increment, &resumed_count, nullptr); |
| 1386 | 1383 | 1388 | ||
| 1387 | 1384 | /* Get our app object */ | 1389 | /* Get our app object */ |
| 1389 | 1385 | auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3"); | 1390 | auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3"); |
| 1390 | 1386 | auto app = ubuntu::app_launch::Application::create(appid, registry); | 1391 | auto app = ubuntu::app_launch::Application::create(appid, registry); |
| 1391 | 1387 | 1392 | ||
| 1392 | 1388 | ASSERT_EQ(1, app->instances().size()); | 1393 | ASSERT_EQ(1, app->instances().size()); |
| 1393 | @@ -1488,7 +1493,7 @@ | |||
| 1394 | 1488 | dbus_test_task_get_state(DBUS_TEST_TASK(zgmock)) != DBUS_TEST_TASK_STATE_RUNNING); | 1493 | dbus_test_task_get_state(DBUS_TEST_TASK(zgmock)) != DBUS_TEST_TASK_STATE_RUNNING); |
| 1395 | 1489 | 1494 | ||
| 1396 | 1490 | /* Get our app object */ | 1495 | /* Get our app object */ |
| 1398 | 1491 | auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3"); | 1496 | auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3"); |
| 1399 | 1492 | auto app = ubuntu::app_launch::Application::create(appid, registry); | 1497 | auto app = ubuntu::app_launch::Application::create(appid, registry); |
| 1400 | 1493 | 1498 | ||
| 1401 | 1494 | ASSERT_EQ(1, app->instances().size()); | 1499 | ASSERT_EQ(1, app->instances().size()); |
| 1402 | @@ -1569,7 +1574,7 @@ | |||
| 1403 | 1569 | EXPECT_EVENTUALLY_EQ(DBUS_TEST_TASK_STATE_RUNNING, dbus_test_task_get_state(DBUS_TEST_TASK(cgmock2))); | 1574 | EXPECT_EVENTUALLY_EQ(DBUS_TEST_TASK_STATE_RUNNING, dbus_test_task_get_state(DBUS_TEST_TASK(cgmock2))); |
| 1404 | 1570 | 1575 | ||
| 1405 | 1571 | /* Get our app object */ | 1576 | /* Get our app object */ |
| 1407 | 1572 | auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3"); | 1577 | auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3"); |
| 1408 | 1573 | auto app = ubuntu::app_launch::Application::create(appid, registry); | 1578 | auto app = ubuntu::app_launch::Application::create(appid, registry); |
| 1409 | 1574 | 1579 | ||
| 1410 | 1575 | ASSERT_EQ(1, app->instances().size()); | 1580 | ASSERT_EQ(1, app->instances().size()); |
| 1411 | @@ -1780,7 +1785,7 @@ | |||
| 1412 | 1780 | EXPECT_EQ("Application", app->info()->name().value()); | 1785 | EXPECT_EQ("Application", app->info()->name().value()); |
| 1413 | 1781 | 1786 | ||
| 1414 | 1782 | /* Correct values from a legacy */ | 1787 | /* Correct values from a legacy */ |
| 1416 | 1783 | auto barid = ubuntu::app_launch::AppID::find("bar"); | 1788 | auto barid = ubuntu::app_launch::AppID::find(registry, "bar"); |
| 1417 | 1784 | EXPECT_THROW(ubuntu::app_launch::Application::create(barid, registry), std::runtime_error); | 1789 | EXPECT_THROW(ubuntu::app_launch::Application::create(barid, registry), std::runtime_error); |
| 1418 | 1785 | 1790 | ||
| 1419 | 1786 | /* Correct values for libertine */ | 1791 | /* Correct values for libertine */ |
FAILED: Continuous integration, rev:352
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https:/
https:/
Executed test runs:
FAILURE: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
FAILURE: https:/
Click here to trigger a rebuild:
https:/