static void
gs_editor_refine_app_pixbuf (GsApp *app)
{
GPtrArray *icons;
if (gs_app_get_pixbuf (app) != NULL)
return;
icons = gs_app_get_icons (app);
for (guint i = 0; i < icons->len; i++) {
AsIcon *ic = g_ptr_array_index (icons, i);
g_autoptr(GError) error = NULL;
if (as_icon_get_kind (ic) == AS_ICON_KIND_STOCK) {
g_autoptr(GdkPixbuf) pb = NULL;
pb = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
as_icon_get_name (ic),
64,
GTK_ICON_LOOKUP_FORCE_SIZE,
&error);
if (pb == NULL) {
g_warning ("failed to load icon: %s", error->message);
continue;
}
gs_app_set_pixbuf (app, pb);
} else {
if (!as_icon_load (ic, AS_ICON_LOAD_FLAG_SEARCH_SIZE, &error)) {
g_warning ("failed to load icon: %s", error->message);
continue;
}
gs_app_set_pixbuf (app, as_icon_get_pixbuf (ic));
}
break;
}
}
static gboolean
load_snap_icon (GsApp *app, SnapdClient *client, SnapdSnap *snap, GCancellable *cancellable)
{
const gchar *icon_url;
g_autoptr(SnapdIcon) icon = NULL;
g_autoptr(GInputStream) input_stream = NULL;
g_autoptr(GdkPixbuf) pixbuf = NULL;
g_autoptr(GError) error = NULL;
icon_url = snapd_snap_get_icon (snap);
if (icon_url == NULL || strcmp (icon_url, "") == 0)
return FALSE;
icon = snapd_client_get_icon_sync (client, gs_app_get_metadata_item (app, "snap::name"), cancellable, &error);
if (icon == NULL) {
g_warning ("Failed to load snap icon: %s", error->message);
return FALSE;
}
input_stream = g_memory_input_stream_new_from_bytes (snapd_icon_get_data (icon));
pixbuf = gdk_pixbuf_new_from_stream_at_scale (input_stream, 64, 64, TRUE, cancellable, &error);
if (pixbuf == NULL) {
g_warning ("Failed to decode snap icon %s: %s", icon_url, error->message);
return FALSE;
}
gs_app_set_pixbuf (app, pixbuf);
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_refine_item_pixbuf:
*/
static void
gs_refine_item_pixbuf (GsPlugin *plugin, GsApp *app, AsApp *item)
{
AsIcon *icon;
gboolean ret;
g_autoptr(GError) error = NULL;
g_autofree gchar *fn = NULL;
g_autofree gchar *cachedir = NULL;
icon = as_app_get_icon_default (item);
switch (as_icon_get_kind (icon)) {
case AS_ICON_KIND_REMOTE:
gs_app_set_icon (app, icon);
if (as_icon_get_filename (icon) == NULL) {
cachedir = gs_utils_get_cachedir ("icons", NULL);
fn = g_build_filename (cachedir, as_icon_get_name (icon), NULL);
as_icon_set_filename (icon, fn);
as_icon_set_prefix (icon, cachedir);
}
if (g_file_test (fn, G_FILE_TEST_EXISTS)) {
as_icon_set_kind (icon, AS_ICON_KIND_LOCAL);
ret = gs_app_load_icon (app, plugin->scale, &error);
if (!ret) {
g_warning ("failed to load icon %s: %s",
as_icon_get_name (icon),
error->message);
return;
}
}
break;
case AS_ICON_KIND_STOCK:
case AS_ICON_KIND_LOCAL:
gs_app_set_icon (app, icon);
/* does not exist, so try to find using the icon theme */
if (as_icon_get_kind (icon) == AS_ICON_KIND_LOCAL &&
as_icon_get_filename (icon) == NULL)
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
/* load */
ret = gs_app_load_icon (app, plugin->scale, &error);
if (!ret) {
g_warning ("failed to load %s icon %s: %s",
as_icon_kind_to_string (as_icon_get_kind (icon)),
as_icon_get_name (icon),
error->message);
return;
}
break;
case AS_ICON_KIND_CACHED:
if (plugin->scale == 2)
icon = as_app_get_icon_for_size (item, 128, 128);
if (icon == NULL)
icon = as_app_get_icon_for_size (item, 64, 64);
if (icon == NULL) {
g_warning ("failed to find cached icon %s",
as_icon_get_name (icon));
return;
}
if (!as_icon_load (icon, AS_ICON_LOAD_FLAG_SEARCH_SIZE, &error)) {
g_warning ("failed to load cached icon %s: %s",
as_icon_get_name (icon), error->message);
return;
}
gs_app_set_pixbuf (app, as_icon_get_pixbuf (icon));
break;
default:
g_warning ("icon kind unknown for %s", as_app_get_id (item));
break;
}
}
/**
* gs_plugin_file_to_app:
*/
gboolean
gs_plugin_file_to_app (GsPlugin *plugin,
GList **list,
GFile *file,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *content_type = NULL;
g_autofree gchar *id_prefixed = NULL;
g_autoptr(GBytes) appstream_gz = NULL;
g_autoptr(GBytes) icon_data = NULL;
g_autoptr(GBytes) metadata = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(XdgAppBundleRef) xref_bundle = NULL;
const gchar *mimetypes[] = {
"application/vnd.xdgapp",
NULL };
/* does this match any of the mimetypes we support */
content_type = gs_utils_get_content_type (file, cancellable, error);
if (content_type == NULL)
return FALSE;
if (!g_strv_contains (mimetypes, content_type))
return TRUE;
/* load bundle */
xref_bundle = xdg_app_bundle_ref_new (file, error);
if (xref_bundle == NULL) {
g_prefix_error (error, "error loading bundle: ");
return FALSE;
}
/* create a virtual ID */
id_prefixed = gs_plugin_xdg_app_build_id (XDG_APP_REF (xref_bundle));
/* load metadata */
app = gs_app_new (id_prefixed);
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_set_state (app, AS_APP_STATE_AVAILABLE_LOCAL);
gs_app_set_size_installed (app, xdg_app_bundle_ref_get_installed_size (xref_bundle));
gs_plugin_xdg_app_set_metadata (app, XDG_APP_REF (xref_bundle));
metadata = xdg_app_bundle_ref_get_metadata (xref_bundle);
if (!gs_plugin_xdg_app_set_app_metadata (app,
g_bytes_get_data (metadata, NULL),
g_bytes_get_size (metadata),
error))
return FALSE;
/* load AppStream */
appstream_gz = xdg_app_bundle_ref_get_appstream (xref_bundle);
if (appstream_gz != NULL) {
g_autoptr(GZlibDecompressor) decompressor = NULL;
g_autoptr(GInputStream) stream_gz = NULL;
g_autoptr(GInputStream) stream_data = NULL;
g_autoptr(GBytes) appstream = NULL;
g_autoptr(AsStore) store = NULL;
g_autofree gchar *id = NULL;
AsApp *item;
/* decompress data */
decompressor = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP);
stream_gz = g_memory_input_stream_new_from_bytes (appstream_gz);
if (stream_gz == NULL)
return FALSE;
stream_data = g_converter_input_stream_new (stream_gz,
G_CONVERTER (decompressor));
appstream = g_input_stream_read_bytes (stream_data,
0x100000, /* 1Mb */
cancellable,
error);
if (appstream == NULL)
return FALSE;
store = as_store_new ();
if (!as_store_from_bytes (store, appstream, cancellable, error))
return FALSE;
/* find app */
id = g_strdup_printf ("%s.desktop", gs_app_get_xdgapp_name (app));
item = as_store_get_app_by_id (store, id);
if (item == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"application %s not found",
id);
return FALSE;
}
/* copy details from AppStream to app */
if (!gs_appstream_refine_app (plugin, app, item, error))
return FALSE;
}
/* load icon */
icon_data = xdg_app_bundle_ref_get_icon (xref_bundle,
64 * gs_plugin_get_scale (plugin));
if (icon_data == NULL)
icon_data = xdg_app_bundle_ref_get_icon (xref_bundle, 64);
if (icon_data != NULL) {
g_autoptr(GInputStream) stream_icon = NULL;
g_autoptr(GdkPixbuf) pixbuf = NULL;
stream_icon = g_memory_input_stream_new_from_bytes (icon_data);
pixbuf = gdk_pixbuf_new_from_stream (stream_icon, cancellable, error);
if (pixbuf == NULL)
return FALSE;
gs_app_set_pixbuf (app, pixbuf);
} else {
g_autoptr(AsIcon) icon = NULL;
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "application-x-executable");
gs_app_set_icon (app, icon);
}
/* not quite true: this just means we can update this specific app */
if (xdg_app_bundle_ref_get_origin (xref_bundle))
gs_app_add_quirk (app, AS_APP_QUIRK_HAS_SOURCE);
g_debug ("created local app: %s", gs_app_to_string (app));
gs_app_list_add (list, app);
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);
}
}