static GsApp*
gs_plugin_app_from_pki (LiPkgInfo *pki)
{
const gchar *cptkind_str;
GsApp *app;
cptkind_str = li_pkg_info_get_component_kind (pki);
if ((cptkind_str != NULL) && (g_strcmp0 (cptkind_str, "desktop") == 0)) {
g_autofree gchar *tmp = NULL;
/* type=desktop AppStream components result in a Limba bundle name which has the .desktop stripped away.
* We need to re-add it for GNOME Software.
* In any other case, the Limba bundle name equals the AppStream ID of the component it contains */
tmp = g_strdup_printf ("%s.desktop", li_pkg_info_get_name (pki));
app = gs_app_new (tmp);
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
} else {
app = gs_app_new (li_pkg_info_get_name (pki));
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
}
/* TODO: scope?, branch? */
gs_app_set_management_plugin (app, "limba");
gs_app_set_state (app, AS_APP_STATE_UPDATABLE_LIVE);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_LIMBA);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
li_pkg_info_get_name (pki));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
li_pkg_info_get_name (pki));
gs_app_set_version (app, li_pkg_info_get_version (pki));
gs_app_add_source (app, li_pkg_info_get_id (pki));
return app;
}
/**
* gs_plugin_add_unvoted_reviews:
*/
gboolean
gs_plugin_add_unvoted_reviews (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
const gchar *app_id_last = NULL;
guint status_code;
guint i;
g_autofree gchar *uri = NULL;
g_autoptr(GFile) cachefn_file = NULL;
g_autoptr(GPtrArray) reviews = NULL;
g_autoptr(GsApp) app_current = NULL;
g_autoptr(SoupMessage) msg = NULL;
/* create the GET data *with* the machine hash so we can later
* review the application ourselves */
uri = g_strdup_printf ("%s/moderate/%s",
plugin->priv->review_server,
plugin->priv->user_hash);
msg = soup_message_new (SOUP_METHOD_GET, uri);
status_code = soup_session_send_message (plugin->soup_session, msg);
if (status_code != SOUP_STATUS_OK) {
if (!xdg_app_review_parse_success (msg->response_body->data,
msg->response_body->length,
error))
return FALSE;
/* not sure what to do here */
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"status code invalid");
return FALSE;
}
g_debug ("xdg-app-review returned: %s", msg->response_body->data);
reviews = xdg_app_review_parse_reviews (msg->response_body->data,
msg->response_body->length,
error);
if (reviews == NULL)
return FALSE;
/* look at all the reviews; faking application objects */
for (i = 0; i < reviews->len; i++) {
GsReview *review;
const gchar *app_id;
/* same app? */
review = g_ptr_array_index (reviews, i);
app_id = gs_review_get_metadata_item (review, "app_id");
if (g_strcmp0 (app_id, app_id_last) != 0) {
g_clear_object (&app_current);
app_current = gs_app_new (app_id);
gs_plugin_add_app (list, app_current);
app_id_last = app_id;
}
gs_app_add_review (app_current, review);
}
return TRUE;
}
/**
* gs_plugin_xdg_app_create_installed:
*/
static GsApp *
gs_plugin_xdg_app_create_installed (GsPlugin *plugin,
XdgAppInstalledRef *xref,
GError **error)
{
g_autofree gchar *id = NULL;
g_autoptr(AsIcon) icon = NULL;
g_autoptr(GsApp) app = NULL;
g_return_val_if_fail (xref != NULL, NULL);
/*
* Only show the current application in GNOME Software
*
* You can have multiple versions/branches of a particular app-id
* installed but only one of them is "current" where this means:
* 1) the default to launch unless you specify a version
* 2) The one that gets its exported files exported
*/
if (!xdg_app_installed_ref_get_is_current (xref) &&
xdg_app_ref_get_kind (XDG_APP_REF(xref)) == XDG_APP_REF_KIND_APP) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"%s not current, ignoring",
xdg_app_ref_get_name (XDG_APP_REF (xref)));
return NULL;
}
/* create new object */
id = gs_plugin_xdg_app_build_id (XDG_APP_REF (xref));
app = gs_app_new (id);
gs_plugin_xdg_app_set_metadata_installed (app, xref);
switch (xdg_app_ref_get_kind (XDG_APP_REF(xref))) {
case XDG_APP_REF_KIND_APP:
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
break;
case XDG_APP_REF_KIND_RUNTIME:
gs_app_set_xdgapp_kind (app, XDG_APP_REF_KIND_RUNTIME);
gs_app_set_kind (app, AS_APP_KIND_RUNTIME);
gs_app_set_name (app, GS_APP_QUALITY_NORMAL,
xdg_app_ref_get_name (XDG_APP_REF (xref)));
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL,
"Framework for applications");
gs_app_set_version (app, xdg_app_ref_get_branch (XDG_APP_REF (xref)));
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "system-run-symbolic");
gs_app_set_icon (app, icon);
break;
default:
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"XdgAppRefKind not known");
return NULL;
}
return g_object_ref (app);
}
/**
* gs_plugin_add_popular:
*/
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
guint i;
const gchar *apps[] = {
"org.gnome.Builder.desktop",
"org.gnome.Calculator.desktop",
"org.gnome.clocks.desktop",
"org.gnome.Dictionary.desktop",
"org.gnome.Documents.desktop",
"org.gnome.Evince.desktop",
"org.gnome.gedit.desktop",
"org.gnome.Maps.desktop",
"org.gnome.Weather.desktop",
NULL };
/* just add all */
for (i = 0; apps[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
app = gs_app_new (apps[i]);
gs_app_list_add (list, app);
}
return TRUE;
}
void
gs_shell_show_details (GsShell *shell, const gchar *id)
{
g_autoptr(GsApp) app = NULL;
app = gs_app_new (id);
gs_shell_show_app (shell, app);
}
/**
* gs_appstream_refine_add_addons:
*/
static void
gs_appstream_refine_add_addons (GsPlugin *plugin, GsApp *app, AsApp *item)
{
GPtrArray *addons;
guint i;
addons = as_app_get_addons (item);
if (addons == NULL)
return;
for (i = 0; i < addons->len; i++) {
AsApp *as_addon = g_ptr_array_index (addons, i);
g_autoptr(GError) error = NULL;
g_autoptr(GsApp) addon = NULL;
addon = gs_app_new (as_app_get_id (as_addon));
/* add all the data we can */
if (!gs_appstream_refine_app (plugin, addon, as_addon, &error)) {
g_warning ("failed to refine addon: %s", error->message);
continue;
}
gs_app_add_addon (app, addon);
}
}
gboolean
gs_plugin_setup (GsPlugin *plugin, GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* add source */
priv->cached_origin = gs_app_new (gs_plugin_get_name (plugin));
gs_app_set_kind (priv->cached_origin, AS_APP_KIND_SOURCE);
gs_app_set_bundle_kind (priv->cached_origin, AS_BUNDLE_KIND_CABINET);
/* add the source to the plugin cache which allows us to match the
* unique ID to a GsApp when creating an event */
gs_plugin_cache_add (plugin,
gs_app_get_unique_id (priv->cached_origin),
priv->cached_origin);
/* register D-Bus errors */
fwupd_error_quark ();
g_signal_connect (priv->client, "changed",
G_CALLBACK (gs_plugin_fwupd_changed_cb), plugin);
g_signal_connect (priv->client, "device-added",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-removed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-changed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "notify::percentage",
G_CALLBACK (gs_plugin_fwupd_notify_percentage_cb), plugin);
g_signal_connect (priv->client, "notify::status",
G_CALLBACK (gs_plugin_fwupd_notify_status_cb), plugin);
return TRUE;
}
static GsApp *
gs_plugin_generic_updates_get_os_update (GsPlugin *plugin)
{
GsApp *app;
const gchar *id = "org.gnome.Software.OsUpdate";
g_autoptr(AsIcon) ic = NULL;
/* create new */
app = gs_app_new (id);
gs_app_add_quirk (app, GS_APP_QUIRK_IS_PROXY);
gs_app_set_management_plugin (app, "");
gs_app_set_kind (app, AS_APP_KIND_OS_UPDATE);
gs_app_set_state (app, AS_APP_STATE_UPDATABLE_LIVE);
gs_app_set_name (app,
GS_APP_QUALITY_NORMAL,
/* TRANSLATORS: this is a group of updates that are not
* packages and are not shown in the main list */
_("OS Updates"));
gs_app_set_summary (app,
GS_APP_QUALITY_NORMAL,
/* TRANSLATORS: this is a longer description of the
* "OS Updates" string */
_("Includes performance, stability and security improvements."));
gs_app_set_description (app,
GS_APP_QUALITY_NORMAL,
gs_app_get_summary (app));
ic = as_icon_new ();
as_icon_set_kind (ic, AS_ICON_KIND_STOCK);
as_icon_set_name (ic, "software-update-available-symbolic");
gs_app_add_icon (app, ic);
return app;
}
static GsApp *
snap_to_app (GsPlugin *plugin, SnapdSnap *snap)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GStrv common_ids;
g_autofree gchar *appstream_id = NULL;
g_autofree gchar *unique_id = NULL;
g_autoptr(GsApp) app = NULL;
SnapdConfinement confinement;
/* Get the AppStream ID from the snap, or generate a fallback one */
common_ids = snapd_snap_get_common_ids (snap);
if (g_strv_length (common_ids) == 1)
appstream_id = g_strdup (common_ids[0]);
else
appstream_id = g_strdup_printf ("io.snapcraft.%s-%s", snapd_snap_get_name (snap), snapd_snap_get_id (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
unique_id = g_strdup_printf ("system/snap/*/desktop/%s/*", appstream_id);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
unique_id = g_strdup_printf ("system/snap/*/runtime/%s/*", appstream_id);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
unique_id = g_strdup_printf ("system/snap/*/*/%s/*", appstream_id);
break;
}
app = gs_plugin_cache_lookup (plugin, unique_id);
if (app == NULL) {
app = gs_app_new (NULL);
gs_app_set_from_unique_id (app, unique_id);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_metadata (app, "snap::name", snapd_snap_get_name (snap));
gs_plugin_cache_add (plugin, unique_id, app);
}
gs_app_set_management_plugin (app, "snap");
if (gs_app_get_kind (app) != AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
if (gs_plugin_check_distro_id (plugin, "ubuntu"))
gs_app_add_quirk (app, GS_APP_QUIRK_PROVENANCE);
confinement = snapd_snap_get_confinement (snap);
if (confinement != SNAPD_CONFINEMENT_UNKNOWN) {
GEnumClass *enum_class = g_type_class_ref (SNAPD_TYPE_CONFINEMENT);
gs_app_set_metadata (app, "snap::confinement", g_enum_get_value (enum_class, confinement)->value_nick);
g_type_class_unref (enum_class);
}
if (priv->system_confinement == SNAPD_SYSTEM_CONFINEMENT_STRICT && confinement == SNAPD_CONFINEMENT_STRICT)
gs_app_add_kudo (app, GS_APP_KUDO_SANDBOXED);
return g_steal_pointer (&app);
}
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
PkBitfield filter;
PkRepoDetail *rd;
ProgressData data;
const gchar *id;
guint i;
g_autoptr(GHashTable) hash = NULL;
g_autoptr(PkResults) results = NULL;
g_autoptr(GPtrArray) array = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
/* ask PK for the repo details */
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_NOT_SOURCE,
PK_FILTER_ENUM_NOT_SUPPORTED,
-1);
results = pk_client_get_repo_list (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
array = pk_results_get_repo_detail_array (results);
for (i = 0; i < array->len; i++) {
g_autoptr(GsApp) app = NULL;
rd = g_ptr_array_index (array, i);
id = pk_repo_detail_get_id (rd);
app = gs_app_new (id);
gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_state (app, pk_repo_detail_get_enabled (rd) ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_list_add (list, app);
g_hash_table_insert (hash,
g_strdup (id),
(gpointer) app);
}
/* get every application on the system and add it as a related package
* if it matches */
return gs_plugin_add_sources_related (plugin, hash, cancellable, error);
}
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
g_autoptr(GError) error_local = NULL;
g_auto(GStrv) package_ids = NULL;
/* get the id's if the file exists */
package_ids = pk_offline_get_prepared_ids (&error_local);
if (package_ids == NULL) {
if (g_error_matches (error_local,
PK_OFFLINE_ERROR,
PK_OFFLINE_ERROR_NO_DATA)) {
return TRUE;
}
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"Failed to get prepared IDs: %s",
error_local->message);
return FALSE;
}
/* add them to the new array */
for (i = 0; package_ids[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
g_auto(GStrv) split = NULL;
/* search in the cache */
app = gs_plugin_cache_lookup (plugin, package_ids[i]);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new app */
app = gs_app_new (NULL);
gs_app_add_quirk (app, AS_APP_QUIRK_NEEDS_REBOOT);
gs_app_set_management_plugin (app, "packagekit");
gs_app_add_source_id (app, package_ids[i]);
split = pk_package_id_split (package_ids[i]);
gs_app_add_source (app, split[PK_PACKAGE_ID_NAME]);
gs_app_set_update_version (app, split[PK_PACKAGE_ID_VERSION]);
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_size_download (app, 0);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, package_ids[i], app);
}
return TRUE;
}
/**
* gs_plugin_add_updates:
*/
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
GsApp *app;
/* update UI as this might take some time */
gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_WAITING);
/* spin */
g_usleep (2 * G_USEC_PER_SEC);
/* add a normal application */
app = gs_app_new ("gnome-boxes");
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, "Boxes");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, "Do not segfault when using newer versons of libvirt.");
gs_app_set_kind (app, GS_APP_KIND_NORMAL);
gs_app_set_id_kind (app, AS_ID_KIND_DESKTOP);
gs_plugin_add_app (list, app);
g_object_unref (app);
/* add an OS update */
app = gs_app_new ("libvirt-glib-devel;0.0.1;noarch;fedora");
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, "libvirt-glib-devel");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, "Fix several memory leaks.");
gs_app_set_kind (app, GS_APP_KIND_PACKAGE);
gs_app_set_id_kind (app, AS_ID_KIND_DESKTOP);
gs_plugin_add_app (list, app);
g_object_unref (app);
/* add a second OS update */
app = gs_app_new ("gnome-boxes-libs;0.0.1;i386;updates-testing");
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, "gnome-boxes-libs");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, "Do not segfault when using newer versons of libvirt.");
gs_app_set_kind (app, GS_APP_KIND_PACKAGE);
gs_app_set_id_kind (app, AS_ID_KIND_DESKTOP);
gs_plugin_add_app (list, app);
g_object_unref (app);
return TRUE;
}
void
gs_plugin_initialize (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_alloc_data (plugin, sizeof(GsPluginData));
g_autoptr(GError) error = NULL;
g_autoptr(GsOsRelease) os_release = NULL;
priv->settings = g_settings_new ("org.gnome.software");
priv->review_server = g_settings_get_string (priv->settings,
"review-server");
priv->ratings = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_array_unref);
/* get the machine+user ID hash value */
priv->user_hash = gs_utils_get_user_hash (&error);
if (priv->user_hash == NULL) {
g_warning ("Failed to get machine+user hash: %s", error->message);
return;
}
/* get the distro name (e.g. 'Fedora') but allow a fallback */
os_release = gs_os_release_new (&error);
if (os_release != NULL) {
priv->distro = g_strdup (gs_os_release_get_name (os_release));
if (priv->distro == NULL) {
g_warning ("no distro name specified");
priv->distro = g_strdup ("Unknown");
}
} else {
g_warning ("failed to get distro name: %s", error->message);
priv->distro = g_strdup ("Unknown");
}
/* add source */
priv->cached_origin = gs_app_new (gs_plugin_get_name (plugin));
gs_app_set_kind (priv->cached_origin, AS_APP_KIND_SOURCE);
gs_app_set_origin_hostname (priv->cached_origin, priv->review_server);
gs_app_set_origin_ui (priv->cached_origin, "Open Desktop Review Server");
/* add the source to the plugin cache which allows us to match the
* unique ID to a GsApp when creating an event */
gs_plugin_cache_add (plugin,
gs_app_get_unique_id (priv->cached_origin),
priv->cached_origin);
/* need application IDs and version */
gs_plugin_add_rule (plugin, GS_PLUGIN_RULE_RUN_AFTER, "appstream");
gs_plugin_add_rule (plugin, GS_PLUGIN_RULE_RUN_AFTER, "flatpak-system");
gs_plugin_add_rule (plugin, GS_PLUGIN_RULE_RUN_AFTER, "flatpak-user");
/* set name of MetaInfo file */
gs_plugin_set_appstream_id (plugin, "org.gnome.Software.Plugin.Odrs");
}
static GsApp *
gs_plugin_fwupd_new_app_from_device (GsPlugin *plugin, FwupdDevice *dev)
{
FwupdRelease *rel = fwupd_device_get_release_default (dev);
GsApp *app;
g_autofree gchar *id = NULL;
g_autoptr(AsIcon) icon = NULL;
/* older versions of fwups didn't record this for historical devices */
if (fwupd_release_get_appstream_id (rel) == NULL)
return NULL;
/* get from cache */
id = as_utils_unique_id_build (AS_APP_SCOPE_SYSTEM,
AS_BUNDLE_KIND_UNKNOWN,
NULL, /* origin */
AS_APP_KIND_FIRMWARE,
fwupd_release_get_appstream_id (rel),
NULL);
app = gs_plugin_cache_lookup (plugin, id);
if (app == NULL) {
app = gs_app_new (id);
gs_plugin_cache_add (plugin, id, app);
}
/* default stuff */
gs_app_set_kind (app, AS_APP_KIND_FIRMWARE);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_CABINET);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
gs_app_set_management_plugin (app, "fwupd");
gs_app_add_category (app, "System");
gs_fwupd_app_set_device_id (app, fwupd_device_get_id (dev));
/* create icon */
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "application-x-firmware");
gs_app_add_icon (app, icon);
gs_fwupd_app_set_from_release (app, rel);
gs_fwupd_app_set_from_device (app, dev);
if (fwupd_release_get_appstream_id (rel) != NULL)
gs_app_set_id (app, fwupd_release_get_appstream_id (rel));
/* the same as we have already */
if (g_strcmp0 (fwupd_device_get_version (dev),
fwupd_release_get_version (rel)) == 0) {
g_warning ("same firmware version as installed");
}
return app;
}
static GsApp *
gs_plugin_create_app_dummy (const gchar *id)
{
GsApp *app = gs_app_new (id);
g_autoptr(GString) str = NULL;
str = g_string_new (id);
as_utils_string_replace (str, ".desktop", "");
g_string_prepend (str, "No description is available for ");
gs_app_set_name (app, GS_APP_QUALITY_LOWEST, "Unknown Application");
gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, "Application not found");
gs_app_set_description (app, GS_APP_QUALITY_LOWEST, str->str);
return app;
}
/**
* gs_plugin_add_popular:
*/
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GsApp) app = gs_app_new ("gnome-power-manager");
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, "Power Manager");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, "Power Management Program");
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
gs_app_set_kind (app, GS_APP_KIND_NORMAL);
gs_plugin_add_app (list, app);
gs_app_set_id_kind (app, AS_ID_KIND_DESKTOP);
return TRUE;
}
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
const gchar *apps[] = {
"org.gnome.Builder.desktop",
"org.gnome.Calculator.desktop",
"org.gnome.clocks.desktop",
"org.gnome.Dictionary.desktop",
"org.gnome.Documents.desktop",
"org.gnome.Evince.desktop",
"org.gnome.gedit.desktop",
"org.gnome.Maps.desktop",
"org.gnome.Weather.desktop",
NULL };
/* we've already got enough popular apps */
if (gs_app_list_length (list) >= 5)
return TRUE;
/* just add all */
g_debug ("using hardcoded as only %u apps", gs_app_list_length (list));
for (i = 0; apps[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
/* look in the cache */
app = gs_plugin_cache_lookup (plugin, apps[i]);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new */
app = gs_app_new (apps[i]);
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_set_metadata (app, "GnomeSoftware::Creator",
gs_plugin_get_name (plugin));
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, apps[i], app);
}
return TRUE;
}
gboolean
gs_plugin_add_search (GsPlugin *plugin,
gchar **values,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
for (i = 0; values[i] != NULL; i++) {
if (g_strcmp0 (values[i], "fotoshop") == 0) {
g_autoptr(GsApp) app = gs_app_new ("gimp.desktop");
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_list_add (list, app);
}
}
return TRUE;
}
/**
* gs_plugin_add_category_apps:
*/
gboolean
gs_plugin_add_category_apps (GsPlugin *plugin,
GsCategory *category,
GList **list,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GsApp) app = gs_app_new ("gnome-boxes");
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, "Boxes");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, "View and use virtual machines");
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE, "http://www.box.org");
gs_app_set_kind (app, GS_APP_KIND_NORMAL);
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
gs_app_set_pixbuf (app, gdk_pixbuf_new_from_file ("/usr/share/icons/hicolor/48x48/apps/gnome-boxes.png", NULL));
gs_app_set_id_kind (app, AS_ID_KIND_DESKTOP);
gs_plugin_add_app (list, app);
return TRUE;
}
/**
* gs_plugin_loader_get_app_by_id:
*/
GsApp *
gs_plugin_loader_get_app_by_id (GsPluginLoader *plugin_loader,
const gchar *id,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsApp *app;
gboolean ret;
app = gs_app_new (id);
app = gs_plugin_loader_dedupe (plugin_loader, app);
ret = gs_plugin_loader_app_refine (plugin_loader, app, flags,
cancellable, error);
if (!ret)
g_clear_object (&app);
return app;
}
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GPtrArray) remotes = NULL;
/* find all remotes */
remotes = fwupd_client_get_remotes (priv->client, cancellable, error);
if (remotes == NULL)
return FALSE;
for (guint i = 0; i < remotes->len; i++) {
FwupdRemote *remote = g_ptr_array_index (remotes, i);
g_autofree gchar *id = NULL;
g_autoptr(GsApp) app = NULL;
/* ignore these, they're built in */
if (fwupd_remote_get_kind (remote) != FWUPD_REMOTE_KIND_DOWNLOAD)
continue;
/* create something that we can use to enable/disable */
id = g_strdup_printf ("org.fwupd.%s.remote", fwupd_remote_get_id (remote));
app = gs_app_new (id);
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_state (app, fwupd_remote_get_enabled (remote) ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
gs_app_set_name (app, GS_APP_QUALITY_LOWEST,
fwupd_remote_get_title (remote));
#if FWUPD_CHECK_VERSION(1,0,7)
gs_app_set_agreement (app, fwupd_remote_get_agreement (remote));
#endif
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE,
fwupd_remote_get_metadata_uri (remote));
gs_app_set_metadata (app, "fwupd::remote-id",
fwupd_remote_get_id (remote));
gs_app_set_management_plugin (app, "fwupd");
gs_app_list_add (list, app);
}
return TRUE;
}
static gboolean
gs_plugin_steam_update_store (GsPlugin *plugin, AsStore *store, GPtrArray *apps, GError **error)
{
guint i;
gdouble pc;
GHashTable *app;
g_autoptr(GsApp) dummy = gs_app_new (NULL);
for (i = 0; i < apps->len; i++) {
app = g_ptr_array_index (apps, i);
if (!gs_plugin_steam_update_store_app (plugin, store, app, error))
return FALSE;
/* update progress */
pc = (gdouble) i * 100.f / (gdouble) apps->len;
gs_app_set_progress (dummy, (guint) pc);
gs_plugin_status_update (plugin, dummy, GS_PLUGIN_STATUS_DOWNLOADING);
}
return TRUE;
}
/**
* gs_plugin_add_sources:
*/
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GPtrArray) xremotes = NULL;
guint i;
xremotes = xdg_app_installation_list_remotes (priv->installation,
cancellable,
error);
if (xremotes == NULL)
return FALSE;
for (i = 0; i < xremotes->len; i++) {
XdgAppRemote *xremote = g_ptr_array_index (xremotes, i);
g_autoptr(GsApp) app = NULL;
/* apps installed from bundles add their own remote that only
* can be used for updating that app only -- so hide them */
if (xdg_app_remote_get_noenumerate (xremote))
continue;
app = gs_app_new (xdg_app_remote_get_name (xremote));
gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
xdg_app_remote_get_name (xremote));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
xdg_app_remote_get_title (xremote));
gs_app_set_url (app,
AS_URL_KIND_HOMEPAGE,
xdg_app_remote_get_url (xremote));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *macaroon = NULL;
g_auto(GStrv) discharges = NULL;
g_autoptr(JsonArray) result = NULL;
guint i;
get_macaroon (plugin, &macaroon, &discharges);
result = gs_snapd_list (macaroon, discharges, cancellable, error);
if (result == NULL)
return FALSE;
for (i = 0; i < json_array_get_length (result); i++) {
JsonObject *package = json_array_get_object_element (result, i);
g_autoptr(GsApp) app = NULL;
const gchar *status, *name;
status = json_object_get_string_member (package, "status");
if (g_strcmp0 (status, "active") != 0)
continue;
/* create a unique ID for deduplication, TODO: branch? */
name = json_object_get_string_member (package, "name");
app = gs_app_new (name);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_management_plugin (app, "snap");
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_REVIEWABLE);
refine_app (plugin, app, package, TRUE, cancellable);
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_featured (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
/* we've already got enough featured apps */
if (gs_app_list_length (list) >= 5)
return TRUE;
/* just add all */
g_debug ("using hardcoded as only %u apps", gs_app_list_length (list));
for (i = 0; myapps[i].id != NULL; i++) {
g_autoptr(GsApp) app = NULL;
/* look in the cache */
app = gs_plugin_cache_lookup (plugin, myapps[i].id);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new */
app = gs_app_new (myapps[i].id);
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_set_metadata (app, "GnomeSoftware::Creator",
gs_plugin_get_name (plugin));
gs_app_set_metadata (app, "GnomeSoftware::FeatureTile-css",
myapps[i].css);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, myapps[i].id, app);
}
return TRUE;
}
static gboolean
gs_plugin_odrs_refresh_ratings (GsPlugin *plugin,
guint cache_age,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autofree gchar *fn = NULL;
g_autofree gchar *uri = NULL;
g_autoptr(GsApp) app_dl = gs_app_new (gs_plugin_get_name (plugin));
/* check cache age */
fn = gs_utils_get_cache_filename ("ratings",
"odrs.json",
GS_UTILS_CACHE_FLAG_WRITEABLE,
error);
if (fn == NULL)
return FALSE;
if (cache_age > 0) {
guint tmp;
g_autoptr(GFile) file = NULL;
file = g_file_new_for_path (fn);
tmp = gs_utils_get_file_age (file);
if (tmp < cache_age) {
g_debug ("%s is only %u seconds old, so ignoring refresh",
fn, tmp);
return gs_plugin_odrs_load_ratings (plugin, fn, error);
}
}
/* download the complete file */
uri = g_strdup_printf ("%s/ratings", priv->review_server);
if (!gs_plugin_download_file (plugin, app_dl, uri, fn, cancellable, error)) {
gs_utils_error_add_unique_id (error, priv->cached_origin);
return FALSE;
}
return gs_plugin_odrs_load_ratings (plugin, fn, error);
}
static GsApp *
gs_plugin_fwupd_new_app_from_device_raw (GsPlugin *plugin, FwupdDevice *device)
{
GPtrArray *icons;
g_autofree gchar *id = NULL;
g_autoptr(GsApp) app = NULL;
/* create a GsApp based on the device, not the release */
id = gs_plugin_fwupd_build_device_id (device);
app = gs_app_new (id);
gs_app_set_kind (app, AS_APP_KIND_FIRMWARE);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
gs_app_set_version (app, fwupd_device_get_version (device));
gs_app_set_name (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_name (device));
gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_summary (device));
gs_app_set_description (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_description (device));
gs_app_set_origin (app, fwupd_device_get_vendor (device));
gs_fwupd_app_set_device_id (app, fwupd_device_get_id (device));
gs_app_set_management_plugin (app, "fwupd");
/* create icon */
icons = fwupd_device_get_icons (device);
for (guint j = 0; j < icons->len; j++) {
const gchar *icon = g_ptr_array_index (icons, j);
g_autoptr(AsIcon) icon_tmp = as_icon_new ();
if (g_str_has_prefix (icon, "/")) {
as_icon_set_kind (icon_tmp, AS_ICON_KIND_LOCAL);
as_icon_set_filename (icon_tmp, icon);
} else {
as_icon_set_kind (icon_tmp, AS_ICON_KIND_STOCK);
as_icon_set_name (icon_tmp, icon);
}
gs_app_add_icon (app, icon_tmp);
}
return g_steal_pointer (&app);
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
const gchar *keys[] = {
"GnomeSoftware::AppTile-css",
"GnomeSoftware::FeatureTile-css",
"GnomeSoftware::UpgradeBanner-css",
NULL };
/* rewrite URIs */
for (guint i = 0; keys[i] != NULL; i++) {
const gchar *css = gs_app_get_metadata_item (app, keys[i]);
if (css != NULL) {
g_autofree gchar *css_new = NULL;
g_autoptr(GsApp) app_dl = gs_app_new (gs_plugin_get_name (plugin));
gs_app_set_summary_missing (app_dl,
/* TRANSLATORS: status text when downloading */
_("Downloading featured images…"));
css_new = gs_plugin_download_rewrite_resource (plugin,
app,
css,
cancellable,
error);
if (css_new == NULL)
return FALSE;
if (g_strcmp0 (css, css_new) != 0) {
gs_app_set_metadata (app, keys[i], NULL);
gs_app_set_metadata (app, keys[i], css_new);
}
}
}
return TRUE;
}
/**
* gs_appstream_create_runtime:
*/
GsApp *
gs_appstream_create_runtime (GsApp *parent, const gchar *runtime)
{
const gchar *id_parent;
g_autofree gchar *id = NULL;
g_autofree gchar *source = NULL;
g_auto(GStrv) id_split = NULL;
g_auto(GStrv) runtime_split = NULL;
g_autoptr(GsApp) app = NULL;
/* get the name/arch/branch */
runtime_split = g_strsplit (runtime, "/", -1);
if (g_strv_length (runtime_split) != 3)
return NULL;
/* find the parent app ID prefix */
id_parent = gs_app_get_id (parent);
if (id_parent == NULL)
return NULL;
id_split = g_strsplit (id_parent, ":", 2);
if (g_strv_length (id_split) == 2) {
id = g_strdup_printf ("%s:%s.runtime",
id_split[0],
runtime_split[0]);
} else {
id = g_strdup_printf ("%s.runtime", runtime_split[0]);
}
/* create the complete GsApp from the single string */
app = gs_app_new (id);
source = g_strdup_printf ("runtime/%s", runtime);
gs_app_add_source (app, source);
gs_app_set_kind (app, AS_APP_KIND_RUNTIME);
gs_app_set_version (app, id_split[2]);
return g_steal_pointer (&app);
}
/**
* gs_plugin_add_featured_app:
*/
static gboolean
gs_plugin_add_featured_app (GList **list,
GKeyFile *kf,
const gchar *id,
GError **error)
{
_cleanup_free_ gchar *background = NULL;
_cleanup_free_ gchar *stroke_color = NULL;
_cleanup_free_ gchar *text_color = NULL;
_cleanup_free_ gchar *text_shadow = NULL;
_cleanup_object_unref_ GsApp *app = NULL;
background = g_key_file_get_string (kf, id, "background", error);
if (background == NULL)
return FALSE;
stroke_color = g_key_file_get_string (kf, id, "stroke", error);
if (stroke_color == NULL)
return FALSE;
text_color = g_key_file_get_string (kf, id, "text", error);
if (text_color == NULL)
return FALSE;
/* optional */
text_shadow = g_key_file_get_string (kf, id, "text-shadow", NULL);
/* add app */
app = gs_app_new (id);
gs_app_add_kudo (app, GS_APP_KUDO_FEATURED_RECOMMENDED);
gs_app_set_metadata (app, "Featured::background", background);
gs_app_set_metadata (app, "Featured::stroke-color", stroke_color);
gs_app_set_metadata (app, "Featured::text-color", text_color);
if (text_shadow != NULL)
gs_app_set_metadata (app, "Featured::text-shadow", text_shadow);
gs_plugin_add_app (list, app);
return TRUE;
}
