/** * gs_screenshot_image_load_async: **/ void gs_screenshot_image_load_async (GsScreenshotImage *ssimg, GCancellable *cancellable) { AsImage *im = NULL; GsScreenshotImagePrivate *priv; SoupURI *base_uri = NULL; const gchar *url; gint rc; _cleanup_free_ gchar *basename = NULL; _cleanup_free_ gchar *cachedir2 = NULL; _cleanup_free_ gchar *cachedir = NULL; _cleanup_free_ gchar *sizedir = NULL; g_return_if_fail (GS_IS_SCREENSHOT_IMAGE (ssimg)); priv = gs_screenshot_image_get_instance_private (ssimg); g_return_if_fail (AS_IS_SCREENSHOT (priv->screenshot)); g_return_if_fail (priv->width != 0); g_return_if_fail (priv->height != 0); /* load an image according to the scale factor */ priv->scale = gtk_widget_get_scale_factor (GTK_WIDGET (ssimg)); im = as_screenshot_get_image (priv->screenshot, priv->width * priv->scale, priv->height * priv->scale); /* if we've failed to load a HiDPI image, fallback to LoDPI */ if (im == NULL && priv->scale > 1) { priv->scale = 1; im = as_screenshot_get_image (priv->screenshot, priv->width, priv->height); } if (im == NULL) { /* TRANSLATORS: this is when we request a screenshot size that * the generator did not create or the parser did not add */ gs_screenshot_image_set_error (ssimg, _("Screenshot size not found")); return; } url = as_image_get_url (im); basename = g_path_get_basename (url); if (priv->width == G_MAXUINT || priv->height == G_MAXUINT) { sizedir = g_strdup ("unknown"); } else { sizedir = g_strdup_printf ("%ux%u", priv->width * priv->scale, priv->height * priv->scale); } cachedir = g_build_filename (priv->cachedir, "gnome-software", "screenshots", sizedir, NULL); rc = g_mkdir_with_parents (cachedir, 0700); if (rc != 0) { /* TRANSLATORS: this is when we try create the cache directory * but we were out of space or permission was denied */ gs_screenshot_image_set_error (ssimg, _("Could not create cache")); return; } /* does local file already exist */ priv->filename = g_build_filename (cachedir, basename, NULL); if (g_file_test (priv->filename, G_FILE_TEST_EXISTS)) { as_screenshot_show_image (ssimg); return; } /* can we load a blurred smaller version of this straight away */ if (priv->width > AS_IMAGE_THUMBNAIL_WIDTH && priv->height > AS_IMAGE_THUMBNAIL_HEIGHT) { cachedir2 = g_build_filename (priv->cachedir, "gnome-software", "screenshots", "112x63", basename, NULL); if (g_file_test (cachedir2, G_FILE_TEST_EXISTS)) gs_screenshot_image_show_blurred (ssimg, cachedir2); } /* download file */ g_debug ("downloading %s to %s", url, priv->filename); base_uri = soup_uri_new (url); if (base_uri == NULL || !SOUP_URI_VALID_FOR_HTTP (base_uri)) { /* TRANSLATORS: this is when we try to download a screenshot * that was not a valid URL */ gs_screenshot_image_set_error (ssimg, _("Screenshot not valid")); soup_uri_free (base_uri); return; } /* cancel any previous messages */ if (priv->message != NULL) { soup_session_cancel_message (priv->session, priv->message, SOUP_STATUS_CANCELLED); g_clear_object (&priv->message); } priv->message = soup_message_new_from_uri (SOUP_METHOD_GET, base_uri); if (priv->message == NULL) { /* TRANSLATORS: this is when networking is not available */ gs_screenshot_image_set_error (ssimg, _("Screenshot not available")); soup_uri_free (base_uri); return; } /* send async */ soup_session_queue_message (priv->session, g_object_ref (priv->message) /* transfer full */, gs_screenshot_image_complete_cb, g_object_ref (ssimg)); soup_uri_free (base_uri); }
void gs_screenshot_image_load_async (GsScreenshotImage *ssimg, GCancellable *cancellable) { AsImage *im = NULL; const gchar *url; g_autofree gchar *basename = NULL; g_autofree gchar *cache_kind = NULL; g_autofree gchar *cachefn_thumb = NULL; g_autofree gchar *sizedir = NULL; g_autoptr(SoupURI) base_uri = NULL; g_return_if_fail (GS_IS_SCREENSHOT_IMAGE (ssimg)); g_return_if_fail (AS_IS_SCREENSHOT (ssimg->screenshot)); g_return_if_fail (ssimg->width != 0); g_return_if_fail (ssimg->height != 0); /* load an image according to the scale factor */ ssimg->scale = (guint) gtk_widget_get_scale_factor (GTK_WIDGET (ssimg)); im = as_screenshot_get_image (ssimg->screenshot, ssimg->width * ssimg->scale, ssimg->height * ssimg->scale); /* if we've failed to load a HiDPI image, fallback to LoDPI */ if (im == NULL && ssimg->scale > 1) { ssimg->scale = 1; im = as_screenshot_get_image (ssimg->screenshot, ssimg->width, ssimg->height); } if (im == NULL) { /* TRANSLATORS: this is when we request a screenshot size that * the generator did not create or the parser did not add */ gs_screenshot_image_set_error (ssimg, _("Screenshot size not found")); return; } /* check if the URL points to a local file */ url = as_image_get_url (im); if (g_str_has_prefix (url, "file://")) { g_free (ssimg->filename); ssimg->filename = g_strdup (url + 7); if (g_file_test (ssimg->filename, G_FILE_TEST_EXISTS)) { as_screenshot_show_image (ssimg); return; } } basename = gs_screenshot_get_cachefn_for_url (url); if (ssimg->width == G_MAXUINT || ssimg->height == G_MAXUINT) { sizedir = g_strdup ("unknown"); } else { sizedir = g_strdup_printf ("%ux%u", ssimg->width * ssimg->scale, ssimg->height * ssimg->scale); } cache_kind = g_build_filename ("screenshots", sizedir, NULL); g_free (ssimg->filename); ssimg->filename = gs_utils_get_cache_filename (cache_kind, basename, GS_UTILS_CACHE_FLAG_NONE, NULL); if (ssimg->filename == NULL) { /* TRANSLATORS: this is when we try create the cache directory * but we were out of space or permission was denied */ gs_screenshot_image_set_error (ssimg, _("Could not create cache")); return; } /* does local file already exist and has recently been downloaded */ if (g_file_test (ssimg->filename, G_FILE_TEST_EXISTS)) { guint64 age_max; g_autoptr(GFile) file = NULL; /* show the image we have in cache while we're checking for the * new screenshot (which probably won't have changed) */ as_screenshot_show_image (ssimg); /* verify the cache age against the maximum allowed */ age_max = g_settings_get_uint (ssimg->settings, "screenshot-cache-age-maximum"); file = g_file_new_for_path (ssimg->filename); /* image new enough, not re-requesting from server */ if (age_max > 0 && gs_utils_get_file_age (file) < age_max) return; } /* if we're not showing a full-size image, we try loading a blurred * smaller version of it straight away */ if (!ssimg->showing_image && ssimg->width > AS_IMAGE_THUMBNAIL_WIDTH && ssimg->height > AS_IMAGE_THUMBNAIL_HEIGHT) { const gchar *url_thumb; g_autofree gchar *basename_thumb = NULL; g_autofree gchar *cache_kind_thumb = NULL; im = as_screenshot_get_image (ssimg->screenshot, AS_IMAGE_THUMBNAIL_WIDTH * ssimg->scale, AS_IMAGE_THUMBNAIL_HEIGHT * ssimg->scale); url_thumb = as_image_get_url (im); basename_thumb = gs_screenshot_get_cachefn_for_url (url_thumb); cache_kind_thumb = g_build_filename ("screenshots", "112x63", NULL); cachefn_thumb = gs_utils_get_cache_filename (cache_kind_thumb, basename_thumb, GS_UTILS_CACHE_FLAG_NONE, NULL); if (cachefn_thumb == NULL) return; if (g_file_test (cachefn_thumb, G_FILE_TEST_EXISTS)) gs_screenshot_image_show_blurred (ssimg, cachefn_thumb); } /* re-request the cache filename, which might be different as it needs * to be writable this time */ g_free (ssimg->filename); ssimg->filename = gs_utils_get_cache_filename (cache_kind, basename, GS_UTILS_CACHE_FLAG_WRITEABLE, NULL); /* download file */ g_debug ("downloading %s to %s", url, ssimg->filename); base_uri = soup_uri_new (url); if (base_uri == NULL || !SOUP_URI_VALID_FOR_HTTP (base_uri)) { /* TRANSLATORS: this is when we try to download a screenshot * that was not a valid URL */ gs_screenshot_image_set_error (ssimg, _("Screenshot not valid")); return; } /* cancel any previous messages */ if (ssimg->message != NULL) { soup_session_cancel_message (ssimg->session, ssimg->message, SOUP_STATUS_CANCELLED); g_clear_object (&ssimg->message); } ssimg->message = soup_message_new_from_uri (SOUP_METHOD_GET, base_uri); if (ssimg->message == NULL) { /* TRANSLATORS: this is when networking is not available */ gs_screenshot_image_set_error (ssimg, _("Screenshot not available")); return; } /* not all servers support If-Modified-Since, but worst case we just * re-download the entire file again every 30 days */ if (g_file_test (ssimg->filename, G_FILE_TEST_EXISTS)) { g_autoptr(GFile) file = g_file_new_for_path (ssimg->filename); gs_screenshot_soup_msg_set_modified_request (ssimg->message, file); } /* send async */ soup_session_queue_message (ssimg->session, g_object_ref (ssimg->message) /* transfer full */, gs_screenshot_image_complete_cb, g_object_ref (ssimg)); }
/** * gs_screenshot_image_complete_cb: **/ static void gs_screenshot_image_complete_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { _cleanup_object_unref_ GsScreenshotImage *ssimg = GS_SCREENSHOT_IMAGE (user_data); GsScreenshotImagePrivate *priv = gs_screenshot_image_get_instance_private (ssimg); gboolean ret; _cleanup_error_free_ GError *error = NULL; _cleanup_object_unref_ AsImage *im = NULL; _cleanup_object_unref_ GdkPixbuf *pixbuf = NULL; _cleanup_object_unref_ GInputStream *stream = NULL; /* return immediately if the message was cancelled or if we're in destruction */ if (msg->status_code == SOUP_STATUS_CANCELLED || priv->session == NULL) return; if (msg->status_code != SOUP_STATUS_OK) { /* TRANSLATORS: this is when we try to download a screenshot and * we get back 404 */ gs_screenshot_image_set_error (ssimg, _("Screenshot not found")); gtk_widget_hide (GTK_WIDGET (ssimg)); return; } /* create a buffer with the data */ stream = g_memory_input_stream_new_from_data (msg->response_body->data, msg->response_body->length, NULL); if (stream == NULL) return; /* load the image */ pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, NULL); if (pixbuf == NULL) { /* TRANSLATORS: possibly image file corrupt or not an image */ gs_screenshot_image_set_error (ssimg, _("Failed to load image")); return; } /* is image size destination size unknown or exactly the correct size */ if (priv->width == G_MAXUINT || priv->height == G_MAXUINT || (priv->width * priv->scale == (guint) gdk_pixbuf_get_width (pixbuf) && priv->height * priv->scale == (guint) gdk_pixbuf_get_height (pixbuf))) { ret = g_file_set_contents (priv->filename, msg->response_body->data, msg->response_body->length, &error); if (!ret) { gs_screenshot_image_set_error (ssimg, error->message); return; } } else { /* save to file, using the same code as the AppStream builder * so the preview looks the same */ im = as_image_new (); as_image_set_pixbuf (im, pixbuf); ret = as_image_save_filename (im, priv->filename, priv->width * priv->scale, priv->height * priv->scale, AS_IMAGE_SAVE_FLAG_PAD_16_9, &error); if (!ret) { gs_screenshot_image_set_error (ssimg, error->message); return; } } /* got image, so show */ as_screenshot_show_image (ssimg); }
static void gs_screenshot_image_complete_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { g_autoptr(GsScreenshotImage) ssimg = GS_SCREENSHOT_IMAGE (user_data); gboolean ret; g_autoptr(GError) error = NULL; g_autoptr(GdkPixbuf) pixbuf = NULL; g_autoptr(GInputStream) stream = NULL; /* return immediately if the message was cancelled or if we're in destruction */ if (msg->status_code == SOUP_STATUS_CANCELLED || ssimg->session == NULL) return; if (msg->status_code == SOUP_STATUS_NOT_MODIFIED) { g_debug ("screenshot has not been modified"); as_screenshot_show_image (ssimg); return; } if (msg->status_code != SOUP_STATUS_OK) { g_warning ("Result of screenshot downloading attempt with " "status code '%u': %s", msg->status_code, msg->reason_phrase); /* if we're already showing an image, then don't set the error * as having an image (even if outdated) is better */ if (ssimg->showing_image) return; /* TRANSLATORS: this is when we try to download a screenshot and * we get back 404 */ gs_screenshot_image_set_error (ssimg, _("Screenshot not found")); return; } /* create a buffer with the data */ stream = g_memory_input_stream_new_from_data (msg->response_body->data, msg->response_body->length, NULL); if (stream == NULL) return; /* load the image */ pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, NULL); if (pixbuf == NULL) { /* TRANSLATORS: possibly image file corrupt or not an image */ gs_screenshot_image_set_error (ssimg, _("Failed to load image")); return; } /* is image size destination size unknown or exactly the correct size */ if (ssimg->width == G_MAXUINT || ssimg->height == G_MAXUINT || (ssimg->width * ssimg->scale == (guint) gdk_pixbuf_get_width (pixbuf) && ssimg->height * ssimg->scale == (guint) gdk_pixbuf_get_height (pixbuf))) { ret = g_file_set_contents (ssimg->filename, msg->response_body->data, msg->response_body->length, &error); if (!ret) { gs_screenshot_image_set_error (ssimg, error->message); return; } } else if (!gs_screenshot_image_save_downloaded_img (ssimg, pixbuf, &error)) { gs_screenshot_image_set_error (ssimg, error->message); return; } /* got image, so show */ as_screenshot_show_image (ssimg); }