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;
}
gboolean
gs_plugin_download_app (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GFile *local_file;
g_autofree gchar *filename = NULL;
/* only process this app if was created by this plugin */
if (g_strcmp0 (gs_app_get_management_plugin (app),
gs_plugin_get_name (plugin)) != 0)
return TRUE;
/* not set */
local_file = gs_app_get_local_file (app);
if (local_file == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"not enough data for fwupd %s",
filename);
return FALSE;
}
/* file does not yet exist */
filename = g_file_get_path (local_file);
if (!g_file_query_exists (local_file, cancellable)) {
const gchar *uri = gs_fwupd_app_get_update_uri (app);
if (!gs_plugin_download_file (plugin, app, uri, filename,
cancellable, error))
return FALSE;
}
gs_app_set_size_download (app, 0);
return TRUE;
}
static GsApp *
gs_plugin_fwupd_new_app (GsPlugin *plugin, FwupdDevice *dev, GError **error)
{
FwupdRelease *rel = fwupd_device_get_release_default (dev);
GPtrArray *checksums;
const gchar *update_uri;
g_autofree gchar *basename = NULL;
g_autofree gchar *filename_cache = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GsApp) app = NULL;
/* update unsupported */
app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
if (gs_app_get_state (app) != AS_APP_STATE_UPDATABLE_LIVE) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"%s [%s] cannot be updated",
gs_app_get_name (app), gs_app_get_id (app));
return NULL;
}
/* some missing */
if (gs_app_get_id (app) == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"fwupd: No id for firmware");
return NULL;
}
if (gs_app_get_version (app) == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"fwupd: No version! for %s!", gs_app_get_id (app));
return NULL;
}
if (gs_app_get_update_version (app) == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"fwupd: No update-version! for %s!", gs_app_get_id (app));
return NULL;
}
checksums = fwupd_release_get_checksums (rel);
if (checksums->len == 0) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NO_SECURITY,
"%s [%s] (%s) has no checksums, ignoring as unsafe",
gs_app_get_name (app),
gs_app_get_id (app),
gs_app_get_update_version (app));
return NULL;
}
update_uri = fwupd_release_get_uri (rel);
if (update_uri == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"no location available for %s [%s]",
gs_app_get_name (app), gs_app_get_id (app));
return NULL;
}
/* does the firmware already exist in the cache? */
basename = g_path_get_basename (update_uri);
filename_cache = gs_utils_get_cache_filename ("fwupd",
basename,
GS_UTILS_CACHE_FLAG_NONE,
error);
if (filename_cache == NULL)
return NULL;
/* delete the file if the checksum does not match */
if (g_file_test (filename_cache, G_FILE_TEST_EXISTS)) {
const gchar *checksum_tmp = NULL;
g_autofree gchar *checksum = NULL;
/* we can migrate to something better than SHA1 when the LVFS
* starts producing metadata with multiple hash types */
checksum_tmp = fwupd_checksum_get_by_kind (checksums,
G_CHECKSUM_SHA1);
if (checksum_tmp == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"No valid checksum for %s",
filename_cache);
}
checksum = gs_plugin_fwupd_get_file_checksum (filename_cache,
G_CHECKSUM_SHA1,
error);
if (checksum == NULL)
return NULL;
if (g_strcmp0 (checksum_tmp, checksum) != 0) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"%s does not match checksum, expected %s got %s",
filename_cache, checksum_tmp, checksum);
g_unlink (filename_cache);
return NULL;
}
}
/* already downloaded, so overwrite */
if (g_file_test (filename_cache, G_FILE_TEST_EXISTS))
gs_app_set_size_download (app, 0);
/* actually add the application */
file = g_file_new_for_path (filename_cache);
gs_app_set_local_file (app, file);
return g_steal_pointer (&app);
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(SnapdClient) client = NULL;
const gchar *name;
g_autoptr(SnapdSnap) local_snap = NULL;
g_autoptr(SnapdSnap) store_snap = NULL;
SnapdSnap *snap;
const gchar *developer_name;
g_autofree gchar *description = NULL;
/* not us */
if (g_strcmp0 (gs_app_get_management_plugin (app), "snap") != 0)
return TRUE;
client = get_client (plugin, error);
if (client == NULL)
return FALSE;
/* get information from local snaps and store */
local_snap = snapd_client_get_snap_sync (client, gs_app_get_metadata_item (app, "snap::name"), cancellable, NULL);
if (local_snap == NULL || (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS) != 0)
store_snap = get_store_snap (plugin, gs_app_get_metadata_item (app, "snap::name"), cancellable, NULL);
if (local_snap == NULL && store_snap == NULL)
return TRUE;
if (local_snap != NULL)
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
else
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
/* use store information for basic metadata over local information */
snap = store_snap != NULL ? store_snap : local_snap;
name = snapd_snap_get_title (snap);
if (name == NULL || g_strcmp0 (name, "") == 0)
name = snapd_snap_get_name (snap);
gs_app_set_name (app, GS_APP_QUALITY_NORMAL, name);
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL, snapd_snap_get_summary (snap));
description = gs_plugin_snap_get_description_safe (snap);
if (description != NULL)
gs_app_set_description (app, GS_APP_QUALITY_NORMAL, description);
gs_app_set_license (app, GS_APP_QUALITY_NORMAL, snapd_snap_get_license (snap));
developer_name = snapd_snap_get_publisher_display_name (snap);
if (developer_name == NULL)
developer_name = snapd_snap_get_publisher_username (snap);
gs_app_set_developer_name (app, developer_name);
if (snapd_snap_get_publisher_validation (snap) == SNAPD_PUBLISHER_VALIDATION_VERIFIED)
gs_app_add_quirk (app, GS_APP_QUIRK_DEVELOPER_VERIFIED);
snap = local_snap != NULL ? local_snap : store_snap;
gs_app_set_version (app, snapd_snap_get_version (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
gs_app_set_kind (app, AS_APP_KIND_RUNTIME);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
gs_app_set_kind (app, AS_APP_KIND_UNKNOWN);
break;
}
/* add information specific to installed snaps */
if (local_snap != NULL) {
SnapdApp *snap_app;
GDateTime *install_date;
install_date = snapd_snap_get_install_date (local_snap);
gs_app_set_size_installed (app, snapd_snap_get_installed_size (local_snap));
gs_app_set_install_date (app, install_date != NULL ? g_date_time_to_unix (install_date) : GS_APP_INSTALL_DATE_UNKNOWN);
snap_app = get_primary_app (local_snap);
if (snap_app != NULL) {
gs_app_set_metadata (app, "snap::launch-name", snapd_app_get_name (snap_app));
gs_app_set_metadata (app, "snap::launch-desktop", snapd_app_get_desktop_file (snap_app));
} else {
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
}
}
/* add information specific to store snaps */
if (store_snap != NULL) {
gs_app_set_origin (app, priv->store_name);
gs_app_set_size_download (app, snapd_snap_get_download_size (store_snap));
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS && gs_app_get_screenshots (app)->len == 0)
refine_screenshots (app, store_snap);
}
/* load icon if requested */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON && gs_app_get_pixbuf (app) == NULL)
load_icon (plugin, client, app, gs_app_get_metadata_item (app, "snap::name"), local_snap, store_snap, cancellable);
return TRUE;
}
/**
* gs_plugin_refine_item_size:
*/
static gboolean
gs_plugin_refine_item_size (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
gboolean ret;
guint64 download_size;
guint64 installed_size;
g_autoptr(AsProfileTask) ptask = NULL;
g_autoptr(GError) error_local = NULL;
/* already set */
if (gs_app_get_size_installed (app) > 0 &&
gs_app_get_size_download (app) > 0)
return TRUE;
/* need commit */
if (!gs_plugin_refine_item_commit (plugin, app, cancellable, error))
return FALSE;
/* need runtime */
if (!gs_plugin_refine_item_runtime (plugin, app, cancellable, error))
return FALSE;
/* calculate the platform size too if the app is not installed */
if (gs_app_get_state (app) == AS_APP_STATE_AVAILABLE &&
gs_app_get_xdgapp_kind (app) == XDG_APP_REF_KIND_APP) {
GsApp *app_runtime;
/* find out what runtime the application depends on */
if (!gs_plugin_refine_item_runtime (plugin,
app,
cancellable,
error))
return FALSE;
/* is the app_runtime already installed? */
app_runtime = gs_app_get_runtime (app);
if (!gs_plugin_refine_item_state (plugin,
app_runtime,
cancellable,
error))
return FALSE;
if (gs_app_get_state (app_runtime) == AS_APP_STATE_INSTALLED) {
g_debug ("runtime %s is already installed, so not adding size",
gs_app_get_id (app_runtime));
} else {
if (!gs_plugin_refine_item_size (plugin,
app_runtime,
cancellable,
error))
return FALSE;
}
}
/* just get the size of the runtime */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-size");
ret = xdg_app_installation_fetch_remote_size_sync (priv->installation,
gs_app_get_origin (app),
gs_app_get_xdgapp_commit (app),
&download_size,
&installed_size,
cancellable, &error_local);
if (!ret) {
g_warning ("libxdgapp failed to return application size: %s",
error_local->message);
gs_app_set_size_installed (app, GS_APP_SIZE_UNKNOWABLE);
gs_app_set_size_download (app, GS_APP_SIZE_UNKNOWABLE);
} else {
gs_app_set_size_installed (app, installed_size);
gs_app_set_size_download (app, download_size);
}
return TRUE;
}
static void
refine_app (GsPlugin *plugin, GsApp *app, JsonObject *package, gboolean from_search, GCancellable *cancellable)
{
g_autofree gchar *macaroon = NULL;
g_auto(GStrv) discharges = NULL;
const gchar *status, *icon_url, *launch_name = NULL;
g_autoptr(GdkPixbuf) icon_pixbuf = NULL;
gint64 size = -1;
get_macaroon (plugin, &macaroon, &discharges);
status = json_object_get_string_member (package, "status");
if (g_strcmp0 (status, "installed") == 0 || g_strcmp0 (status, "active") == 0) {
const gchar *update_available;
update_available = json_object_has_member (package, "update_available") ?
json_object_get_string_member (package, "update_available") : NULL;
if (update_available)
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
else {
if (gs_app_get_state (app) == AS_APP_STATE_AVAILABLE)
gs_app_set_state (app, AS_APP_STATE_UNKNOWN);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
}
} else if (g_strcmp0 (status, "not installed") == 0 || g_strcmp0 (status, "available") == 0) {
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
}
gs_app_set_name (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "summary"));
gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "summary"));
gs_app_set_description (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "description"));
gs_app_set_version (app, json_object_get_string_member (package, "version"));
if (json_object_has_member (package, "installed-size")) {
size = json_object_get_int_member (package, "installed-size");
if (size > 0)
gs_app_set_size_installed (app, (guint64) size);
}
if (json_object_has_member (package, "download-size")) {
size = json_object_get_int_member (package, "download-size");
if (size > 0)
gs_app_set_size_download (app, (guint64) size);
}
gs_app_add_quirk (app, AS_APP_QUIRK_PROVENANCE);
icon_url = json_object_get_string_member (package, "icon");
if (g_str_has_prefix (icon_url, "/")) {
g_autofree gchar *icon_data = NULL;
gsize icon_data_length;
g_autoptr(GError) error = NULL;
icon_data = gs_snapd_get_resource (macaroon, discharges, icon_url, &icon_data_length, cancellable, &error);
if (icon_data != NULL) {
g_autoptr(GdkPixbufLoader) loader = NULL;
loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (loader,
(guchar *) icon_data,
icon_data_length,
NULL);
gdk_pixbuf_loader_close (loader, NULL);
icon_pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
}
else
g_printerr ("Failed to get icon: %s\n", error->message);
}
else {
g_autoptr(SoupMessage) message = NULL;
g_autoptr(GdkPixbufLoader) loader = NULL;
message = soup_message_new (SOUP_METHOD_GET, icon_url);
if (message != NULL) {
soup_session_send_message (gs_plugin_get_soup_session (plugin), message);
loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (loader,
(guint8 *) message->response_body->data,
(gsize) message->response_body->length,
NULL);
gdk_pixbuf_loader_close (loader, NULL);
icon_pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
}
}
if (icon_pixbuf) {
gs_app_set_pixbuf (app, icon_pixbuf);
} else {
g_autoptr(AsIcon) icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "package-x-generic");
gs_app_add_icon (app, icon);
}
if (json_object_has_member (package, "screenshots") && gs_app_get_screenshots (app)->len <= 0) {
JsonArray *screenshots;
guint i;
screenshots = json_object_get_array_member (package, "screenshots");
for (i = 0; i < json_array_get_length (screenshots); i++) {
JsonObject *screenshot = json_array_get_object_element (screenshots, i);
g_autoptr(AsScreenshot) ss = NULL;
g_autoptr(AsImage) image = NULL;
ss = as_screenshot_new ();
as_screenshot_set_kind (ss, AS_SCREENSHOT_KIND_NORMAL);
image = as_image_new ();
as_image_set_url (image, json_object_get_string_member (screenshot, "url"));
as_image_set_kind (image, AS_IMAGE_KIND_SOURCE);
as_screenshot_add_image (ss, image);
gs_app_add_screenshot (app, ss);
}
}
if (!from_search) {
JsonArray *apps;
apps = json_object_get_array_member (package, "apps");
if (apps && json_array_get_length (apps) > 0)
launch_name = json_object_get_string_member (json_array_get_object_element (apps, 0), "name");
if (launch_name)
gs_app_set_metadata (app, "snap::launch-name", launch_name);
else
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_LAUNCHABLE);
}
}
/**
* gs_plugin_refine_app:
*/
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
Header h;
const gchar *fn;
gint rc;
g_auto(rpmdbMatchIterator) mi = NULL;
g_auto(rpmts) ts = NULL;
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_VERSION) == 0 &&
(flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE) == 0 &&
(flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) == 0 &&
(flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION) == 0)
return TRUE;
/* no need to run the plugin */
if (gs_app_get_source_default (app) != NULL &&
gs_app_get_source_id_default (app) != NULL)
return TRUE;
/* open db readonly */
ts = rpmtsCreate();
rpmtsSetRootDir (ts, NULL);
rc = rpmtsOpenDB (ts, O_RDONLY);
if (rc != 0) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to open rpmdb: %i", rc);
return FALSE;
}
/* look for a specific file */
fn = gs_app_get_metadata_item (app, "appstream::source-file");
if (fn == NULL)
return TRUE;
if (!g_str_has_prefix (fn, "/usr"))
return TRUE;
mi = rpmtsInitIterator (ts, RPMDBI_INSTFILENAMES, fn, 0);
if (mi == NULL) {
g_debug ("rpm: no search results for %s", fn);
return TRUE;
}
/* on rpm-ostree this package cannot be removed 'live' */
gs_app_add_quirk (app, AS_APP_QUIRK_COMPULSORY);
/* process any results */
g_debug ("rpm: querying for %s with %s", gs_app_get_id (app), fn);
while ((h = rpmdbNextIterator (mi)) != NULL) {
guint64 epoch;
const gchar *name;
const gchar *version;
const gchar *arch;
const gchar *release;
const gchar *license;
/* add default source */
name = headerGetString (h, RPMTAG_NAME);
if (gs_app_get_source_default (app) == NULL) {
g_debug ("rpm: setting source to %s", name);
gs_app_add_source (app, name);
}
/* set size */
if (gs_app_get_size_download (app) == 0)
gs_app_set_size_download (app, 0);
if (gs_app_get_size_installed (app) == 0) {
guint64 tmp;
tmp = headerGetNumber (h, RPMTAG_SIZE);
gs_app_set_size_installed (app, tmp);
}
/* set license */
license = headerGetString (h, RPMTAG_LICENSE);
if (gs_app_get_license (app) == NULL && license != NULL) {
g_autofree gchar *tmp = NULL;
tmp = as_utils_license_to_spdx (license);
gs_app_set_license (app, GS_APP_QUALITY_NORMAL, tmp);
}
/* add version */
version = headerGetString (h, RPMTAG_VERSION);
if (gs_app_get_version (app) == NULL) {
g_debug ("rpm: setting version to %s", version);
gs_app_set_version (app, version);
}
/* add source-id */
if (gs_app_get_source_id_default (app) == NULL) {
g_autofree gchar *tmp = NULL;
release = headerGetString (h, RPMTAG_RELEASE);
arch = headerGetString (h, RPMTAG_ARCH);
epoch = headerGetNumber (h, RPMTAG_EPOCH);
if (epoch > 0) {
tmp = g_strdup_printf ("%s;%" G_GUINT64_FORMAT ":%s-%s;%s;installed",
name, epoch, version, release, arch);
} else {
tmp = g_strdup_printf ("%s;%s-%s;%s;installed",
name, version, release, arch);
}
g_debug ("rpm: setting source-id to %s", tmp);
gs_app_add_source_id (app, tmp);
}
}
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
const gchar *gameid;
const gchar *tmp;
g_autofree gchar *manifest_basename = NULL;
g_autofree gchar *fn = NULL;
g_autoptr(GHashTable) manifest = NULL;
/* check is us */
gameid = gs_app_get_metadata_item (app, "X-Steam-GameID");
if (gameid == NULL)
return TRUE;
/* is this true? */
gs_app_set_kind (app, AS_ID_KIND_DESKTOP);
/* no way of knowing */
if (gs_app_get_size_download (app) == 0)
gs_app_set_size_download (app, GS_APP_SIZE_UNKNOWABLE);
/* hardcoded */
if (gs_app_get_origin_hostname (app) == NULL)
gs_app_set_origin_hostname (app, "steampowered.com");
/* size */
tmp = gs_app_get_metadata_item (app, "X-Steam-Size");
if (tmp != NULL) {
guint64 sz;
sz = g_ascii_strtoull (tmp, NULL, 10);
if (sz > 0)
gs_app_set_size_installed (app, sz);
}
/* check manifest */
manifest_basename = g_strdup_printf ("appmanifest_%s.acf", gameid);
fn = g_build_filename (g_get_user_data_dir (),
"Steam",
"steamapps",
manifest_basename,
NULL);
if (!g_file_test (fn, G_FILE_TEST_EXISTS)) {
/* can never have been installed */
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
return TRUE;
}
manifest = gs_plugin_steam_load_app_manifest (fn, error);
if (manifest == NULL)
return FALSE;
/* this is better than the download size */
tmp = g_hash_table_lookup (manifest, "SizeOnDisk");
if (tmp != NULL) {
guint64 sz;
sz = g_ascii_strtoull (tmp, NULL, 10);
if (sz > 0)
gs_app_set_size_installed (app, sz);
}
/* set state */
tmp = g_hash_table_lookup (manifest, "StateFlags");
if (tmp != NULL) {
guint64 state_flags;
/* set state */
state_flags = g_ascii_strtoull (tmp, NULL, 10);
if (state_flags & GS_STEAM_STATE_FLAG_DOWNLOADING ||
state_flags & GS_STEAM_STATE_FLAG_PREALLOCATING ||
state_flags & GS_STEAM_STATE_FLAG_ADDING_FILES ||
state_flags & GS_STEAM_STATE_FLAG_COMMITTING ||
state_flags & GS_STEAM_STATE_FLAG_STAGING)
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
else if (state_flags & GS_STEAM_STATE_FLAG_UNINSTALLING)
gs_app_set_state (app, AS_APP_STATE_REMOVING);
else if (state_flags & GS_STEAM_STATE_FLAG_FULLY_INSTALLED)
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
else if (state_flags & GS_STEAM_STATE_FLAG_UNINSTALLED)
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
}
/* set install date */
tmp = g_hash_table_lookup (manifest, "LastUpdated");
if (tmp != NULL) {
guint64 ts;
ts = g_ascii_strtoull (tmp, NULL, 10);
if (ts > 0)
gs_app_set_install_date (app, ts);
}
return TRUE;
}
gboolean
gs_plugin_add_distro_upgrades (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
gsize len;
guint i;
g_autofree gchar *data = NULL;
g_autoptr(GPtrArray) distros = NULL;
g_autoptr(GSettings) settings = NULL;
/* just ensure there is any data, no matter how old */
if (!gs_plugin_fedora_distro_upgrades_refresh (plugin,
G_MAXUINT,
cancellable,
error))
return FALSE;
/* get cached file */
if (!g_file_get_contents (priv->cachefn, &data, &len, error)) {
gs_utils_error_convert_gio (error);
return FALSE;
}
/* parse data */
settings = g_settings_new ("org.gnome.software");
distros = parse_pkgdb_collections_data (data, (gssize) len, error);
if (distros == NULL)
return FALSE;
g_ptr_array_sort (distros, sort_distros_cb);
for (i = 0; i < distros->len; i++) {
DistroInfo *distro_info = g_ptr_array_index (distros, i);
g_autofree gchar *app_id = NULL;
g_autofree gchar *app_version = NULL;
g_autofree gchar *background = NULL;
g_autofree gchar *cache_key = NULL;
g_autofree gchar *url = NULL;
g_autofree gchar *css = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(AsIcon) ic = NULL;
/* only interested in upgrades to the same distro */
if (g_strcmp0 (distro_info->name, priv->os_name) != 0)
continue;
/* only interested in newer versions, but not more than N+2 */
if (distro_info->version <= priv->os_version ||
distro_info->version > priv->os_version + 2)
continue;
/* only interested in non-devel distros */
if (!g_settings_get_boolean (settings, "show-upgrade-prerelease")) {
if (distro_info->status == DISTRO_STATUS_DEVEL)
continue;
}
/* search in the cache */
cache_key = g_strdup_printf ("release-%u", distro_info->version);
app = gs_plugin_cache_lookup (plugin, cache_key);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
app_id = g_strdup_printf ("org.fedoraproject.release-%u.upgrade",
distro_info->version);
app_version = g_strdup_printf ("%u", distro_info->version);
/* icon from disk */
ic = as_icon_new ();
as_icon_set_kind (ic, AS_ICON_KIND_LOCAL);
as_icon_set_filename (ic, "/usr/share/pixmaps/fedora-logo-sprite.png");
/* create */
app = gs_app_new (app_id);
gs_app_set_kind (app, AS_APP_KIND_OS_UPGRADE);
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
gs_app_set_name (app, GS_APP_QUALITY_LOWEST, distro_info->name);
gs_app_set_summary (app, GS_APP_QUALITY_LOWEST,
/* TRANSLATORS: this is a title for Fedora distro upgrades */
_("A major upgrade, with new features and added polish."));
gs_app_set_description (app, GS_APP_QUALITY_LOWEST,
"Fedora Workstation is a polished, "
"easy to use operating system for "
"laptop and desktop computers, with a "
"complete set of tools for developers "
"and makers of all kinds.");
gs_app_set_version (app, app_version);
gs_app_set_size_installed (app, 1024 * 1024 * 1024); /* estimate */
gs_app_set_size_download (app, 256 * 1024 * 1024); /* estimate */
gs_app_set_license (app, GS_APP_QUALITY_LOWEST, "LicenseRef-free");
gs_app_add_quirk (app, AS_APP_QUIRK_NEEDS_REBOOT);
gs_app_add_quirk (app, AS_APP_QUIRK_PROVENANCE);
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_REVIEWABLE);
gs_app_set_origin_ui (app, distro_info->name);
gs_app_add_icon (app, ic);
gs_app_set_management_plugin (app, "packagekit");
/* show a Fedora magazine article for the release */
url = g_strdup_printf ("https://fedoramagazine.org/whats-new-fedora-%u-workstation",
distro_info->version);
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE, url);
/* use a fancy background */
background = get_upgrade_css_background (distro_info->version);
css = g_strdup_printf ("background: %s;"
"background-position: center;"
"background-size: cover;",
background);
gs_app_set_metadata (app, "GnomeSoftware::UpgradeBanner-css", css);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, cache_key, app);
}
return TRUE;
}
