diff options
Diffstat (limited to 'lib/gs-plugin-job-refine.c')
| -rw-r--r-- | lib/gs-plugin-job-refine.c | 860 |
1 files changed, 860 insertions, 0 deletions
diff --git a/lib/gs-plugin-job-refine.c b/lib/gs-plugin-job-refine.c new file mode 100644 index 0000000..f9618cd --- /dev/null +++ b/lib/gs-plugin-job-refine.c @@ -0,0 +1,860 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2021 Endless OS Foundation LLC + * + * Author: Philip Withnall <pwithnall@endlessos.org> + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +/** + * SECTION:gs-plugin-job-refine + * @short_description: A plugin job to refine #GsApps and add more data + * + * #GsPluginJobRefine is a #GsPluginJob representing a refine operation. + * + * It’s used to query and add more data to a set of #GsApps. The data to be set + * is controlled by the #GsPluginRefineFlags, and is looked up for all the apps + * in a #GsAppList by the loaded plugins. + * + * This class is a wrapper around #GsPluginClass.refine_async, calling it for + * all loaded plugins, with some additional refinements done on the results. + * + * In particular, if an app in the #GsAppList has %GS_APP_QUIRK_IS_WILDCARD, + * refining it will replace it with zero or more non-wildcard #GsApps in the + * #GsAppList, all of which are candidates for what the wildcard represents. + * For example, they may have the same ID as the wildcard, or match its name. + * Refining is the canonical process for resolving wildcards. + * + * This means that the #GsAppList at the end of the refine operation may not + * match the #GsAppList passed in as input. Retrieve the final #GsAppList using + * gs_plugin_job_refine_get_result_list(). The #GsAppList which was passed + * into the job will not be modified. + * + * Internally, the #GsPluginClass.refine_async() functions are called on all + * the plugins in series, and in series with a call to + * gs_odrs_provider_refine_async(). Once all of those calls are finished, + * zero or more recursive calls to run_refine_internal_async() are made in + * parallel to do a similar refine process on the addons, runtime and related + * components for all the components in the input #GsAppList. The refine job is + * complete once all these recursive calls complete. + * + * FIXME: Ideally, the #GsPluginClass.refine_async() calls would happen in + * parallel, but this cannot be the case until the results of the refine_async() + * call in one plugin don’t depend on the results of refine_async() in another. + * This still happens with several pairs of plugins. + * + * ``` + * run_async() + * | + * v + * /-----------------------+-------------+----------------\ + * | | | | + * plugin->refine_async() | | | + * v plugin->refine_async() | | + * | v … | + * | | v gs_odrs_provider_refine_async() + * | | | v + * | | | | + * \-----------------------+-------------+----------------/ + * | + * finish_refine_internal_op() + * | + * v + * /----------------------------+-----------------\ + * | | | + * run_refine_internal_async() run_refine_internal_async() … + * | | | + * v v v + * \----------------------------+-----------------/ + * | + * finish_refine_internal_recursion() + * ``` + * + * See also: #GsPluginClass.refine_async + * Since: 42 + */ + +#include "config.h" + +#include <glib.h> +#include <glib-object.h> +#include <glib/gi18n.h> + +#include "gs-app.h" +#include "gs-app-collation.h" +#include "gs-app-private.h" +#include "gs-app-list-private.h" +#include "gs-enums.h" +#include "gs-plugin-job-private.h" +#include "gs-plugin-job-refine.h" +#include "gs-utils.h" + +struct _GsPluginJobRefine +{ + GsPluginJob parent; + + /* Input data. */ + GsAppList *app_list; /* (owned) */ + GsPluginRefineFlags flags; + + /* Output data. */ + GsAppList *result_list; /* (owned) (nullable) */ +}; + +G_DEFINE_TYPE (GsPluginJobRefine, gs_plugin_job_refine, GS_TYPE_PLUGIN_JOB) + +typedef enum { + PROP_APP_LIST = 1, + PROP_FLAGS, +} GsPluginJobRefineProperty; + +static GParamSpec *props[PROP_FLAGS + 1] = { NULL, }; + +static void +gs_plugin_job_refine_dispose (GObject *object) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (object); + + g_clear_object (&self->app_list); + g_clear_object (&self->result_list); + + G_OBJECT_CLASS (gs_plugin_job_refine_parent_class)->dispose (object); +} + +static void +gs_plugin_job_refine_constructed (GObject *object) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (object); + + G_OBJECT_CLASS (gs_plugin_job_refine_parent_class)->constructed (object); + + /* FIXME: the plugins should specify this, rather than hardcoding */ + if (self->flags & (GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_UI | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME)) + self->flags |= GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN; + if (self->flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE) + self->flags |= GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME; +} + +static void +gs_plugin_job_refine_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (object); + + switch ((GsPluginJobRefineProperty) prop_id) { + case PROP_APP_LIST: + g_value_set_object (value, self->app_list); + break; + case PROP_FLAGS: + g_value_set_flags (value, self->flags); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_plugin_job_refine_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (object); + + switch ((GsPluginJobRefineProperty) prop_id) { + case PROP_APP_LIST: + /* Construct only. */ + g_assert (self->app_list == NULL); + self->app_list = g_value_dup_object (value); + g_object_notify_by_pspec (object, props[PROP_APP_LIST]); + break; + case PROP_FLAGS: + /* Construct only. */ + g_assert (self->flags == 0); + self->flags = g_value_get_flags (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +app_is_valid_filter (GsApp *app, + gpointer user_data) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (user_data); + + return gs_plugin_loader_app_is_valid (app, self->flags); +} + +static gint +review_score_sort_cb (gconstpointer a, gconstpointer b) +{ + AsReview *ra = *((AsReview **) a); + AsReview *rb = *((AsReview **) b); + if (as_review_get_priority (ra) < as_review_get_priority (rb)) + return 1; + if (as_review_get_priority (ra) > as_review_get_priority (rb)) + return -1; + return 0; +} + +static gboolean +app_is_non_wildcard (GsApp *app, gpointer user_data) +{ + return !gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD); +} + +static void plugin_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data); +static void odrs_provider_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data); +static void finish_refine_internal_op (GTask *task, + GError *error); +static void recursive_internal_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data); +static void finish_refine_internal_recursion (GTask *task, + GError *error); +static gboolean run_refine_internal_finish (GsPluginJobRefine *self, + GAsyncResult *result, + GError **error); + +typedef struct { + /* Input data. */ + GsPluginLoader *plugin_loader; /* (not nullable) (owned) */ + GsAppList *list; /* (not nullable) (owned) */ + GsPluginRefineFlags flags; + + /* In-progress data. */ + guint n_pending_ops; + guint n_pending_recursions; + guint next_plugin_index; + + /* Output data. */ + GError *error; /* (nullable) (owned) */ +} RefineInternalData; + +static void +refine_internal_data_free (RefineInternalData *data) +{ + g_clear_object (&data->plugin_loader); + g_clear_object (&data->list); + + g_assert (data->n_pending_ops == 0); + g_assert (data->n_pending_recursions == 0); + + /* If an error occurred, it should have been stolen to pass to + * g_task_return_error() by now. */ + g_assert (data->error == NULL); + + g_free (data); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (RefineInternalData, refine_internal_data_free) + +static void +run_refine_internal_async (GsPluginJobRefine *self, + GsPluginLoader *plugin_loader, + GsAppList *list, + GsPluginRefineFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GPtrArray *plugins; /* (element-type GsPlugin) */ + g_autoptr(GTask) task = NULL; + RefineInternalData *data; + g_autoptr(RefineInternalData) data_owned = NULL; + + task = g_task_new (self, cancellable, callback, user_data); + g_task_set_source_tag (task, run_refine_internal_async); + + data = data_owned = g_new0 (RefineInternalData, 1); + data->plugin_loader = g_object_ref (plugin_loader); + data->list = g_object_ref (list); + data->flags = flags; + g_task_set_task_data (task, g_steal_pointer (&data_owned), (GDestroyNotify) refine_internal_data_free); + + /* try to adopt each application with a plugin */ + gs_plugin_loader_run_adopt (plugin_loader, list); + + data->n_pending_ops = 0; + + /* run each plugin + * + * FIXME: For now, we have to run these vfuncs sequentially rather than + * all in parallel. This is because there are still dependencies between + * some of the plugins, where the code to refine an app in one plugin + * depends on the results of refining it in another plugin first. + * + * Eventually, the plugins should all be changed/removed so that they + * can operate independently. At that point, this code can be reverted + * so that the refine_async() vfuncs are called in parallel. */ + plugins = gs_plugin_loader_get_plugins (plugin_loader); + + for (guint i = 0; i < plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (plugins, i); + GsPluginClass *plugin_class = GS_PLUGIN_GET_CLASS (plugin); + + if (!gs_plugin_get_enabled (plugin)) + continue; + if (plugin_class->refine_async == NULL) + continue; + + /* FIXME: The next refine_async() call is made in + * finish_refine_internal_op(). */ + data->next_plugin_index = i + 1; + + /* run the batched plugin symbol */ + data->n_pending_ops++; + plugin_class->refine_async (plugin, list, flags, + cancellable, plugin_refine_cb, g_object_ref (task)); + + /* FIXME: The next refine_async() call is made in + * finish_refine_internal_op(). */ + return; + } + + data->n_pending_ops++; + finish_refine_internal_op (task, NULL); +} + +static void +plugin_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GsPlugin *plugin = GS_PLUGIN (source_object); + g_autoptr(GTask) task = g_steal_pointer (&user_data); + GsPluginClass *plugin_class = GS_PLUGIN_GET_CLASS (plugin); + g_autoptr(GError) local_error = NULL; + + if (!plugin_class->refine_finish (plugin, result, &local_error)) { + finish_refine_internal_op (task, g_steal_pointer (&local_error)); + return; + } + + gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_FINISHED); + + finish_refine_internal_op (task, NULL); +} + +static void +odrs_provider_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GsOdrsProvider *odrs_provider = GS_ODRS_PROVIDER (source_object); + g_autoptr(GTask) task = g_steal_pointer (&user_data); + g_autoptr(GError) local_error = NULL; + + gs_odrs_provider_refine_finish (odrs_provider, result, &local_error); + finish_refine_internal_op (task, g_steal_pointer (&local_error)); +} + +/* @error is (transfer full) if non-NULL */ +static void +finish_refine_internal_op (GTask *task, + GError *error) +{ + GsPluginJobRefine *self = g_task_get_source_object (task); + GCancellable *cancellable = g_task_get_cancellable (task); + g_autoptr(GError) error_owned = g_steal_pointer (&error); + RefineInternalData *data = g_task_get_task_data (task); + GsPluginLoader *plugin_loader = data->plugin_loader; + GsAppList *list = data->list; + GsPluginRefineFlags flags = data->flags; + GsOdrsProvider *odrs_provider; + GsOdrsProviderRefineFlags odrs_refine_flags = 0; + GPtrArray *plugins; /* (element-type GsPlugin) */ + + if (data->error == NULL && error_owned != NULL) { + data->error = g_steal_pointer (&error_owned); + } else if (error_owned != NULL) { + g_debug ("Additional error while refining: %s", error_owned->message); + } + + g_assert (data->n_pending_ops > 0); + data->n_pending_ops--; + + plugins = gs_plugin_loader_get_plugins (plugin_loader); + + for (guint i = data->next_plugin_index; i < plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (plugins, i); + GsPluginClass *plugin_class = GS_PLUGIN_GET_CLASS (plugin); + + if (!gs_plugin_get_enabled (plugin)) + continue; + if (plugin_class->refine_async == NULL) + continue; + + /* FIXME: The next refine_async() call is made in + * finish_refine_internal_op(). */ + data->next_plugin_index = i + 1; + + /* run the batched plugin symbol */ + data->n_pending_ops++; + plugin_class->refine_async (plugin, list, flags, + cancellable, plugin_refine_cb, g_object_ref (task)); + + /* FIXME: The next refine_async() call is made in + * finish_refine_internal_op(). */ + return; + } + + if (data->next_plugin_index == plugins->len) { + /* Avoid the ODRS refine being run multiple times. */ + data->next_plugin_index++; + + /* Add ODRS data if needed */ + odrs_provider = gs_plugin_loader_get_odrs_provider (plugin_loader); + + if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS) + odrs_refine_flags |= GS_ODRS_PROVIDER_REFINE_FLAGS_GET_REVIEWS; + if (flags & (GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING)) + odrs_refine_flags |= GS_ODRS_PROVIDER_REFINE_FLAGS_GET_RATINGS; + + if (odrs_provider != NULL && odrs_refine_flags != 0) { + data->n_pending_ops++; + gs_odrs_provider_refine_async (odrs_provider, list, odrs_refine_flags, + cancellable, odrs_provider_refine_cb, g_object_ref (task)); + } + } + + if (data->n_pending_ops > 0) + return; + + /* At this point, all the plugin->refine() calls are complete and the + * gs_odrs_provider_refine_async() call is also complete. If an error + * occurred during those calls, return with it now rather than + * proceeding to the recursive calls below. */ + if (data->error != NULL) { + g_task_return_error (task, g_steal_pointer (&data->error)); + return; + } + + /* filter any wildcard apps left in the list */ + gs_app_list_filter (list, app_is_non_wildcard, NULL); + + /* ensure these are sorted by score */ + if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS) { + GPtrArray *reviews; + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + reviews = gs_app_get_reviews (app); + g_ptr_array_sort (reviews, review_score_sort_cb); + } + } + + /* Now run several recursive calls to run_refine_internal_async() in + * parallel, to refine related components. */ + data->n_pending_recursions = 1; + + /* refine addons one layer deep */ + if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS) { + g_autoptr(GsAppList) addons_list = gs_app_list_new (); + GsPluginRefineFlags addons_flags = flags; + + addons_flags &= ~(GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS); + + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + g_autoptr(GsAppList) addons = gs_app_dup_addons (app); + + for (guint j = 0; addons != NULL && j < gs_app_list_length (addons); j++) { + GsApp *addon = gs_app_list_index (addons, j); + g_debug ("refining app %s addon %s", + gs_app_get_id (app), + gs_app_get_id (addon)); + gs_app_list_add (addons_list, addon); + } + } + + if (gs_app_list_length (addons_list) > 0 && addons_flags != 0) { + data->n_pending_recursions++; + run_refine_internal_async (self, plugin_loader, + addons_list, addons_flags, + cancellable, recursive_internal_refine_cb, + g_object_ref (task)); + } + } + + /* also do runtime */ + if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME) { + g_autoptr(GsAppList) runtimes_list = gs_app_list_new (); + GsPluginRefineFlags runtimes_flags = flags; + + runtimes_flags &= ~GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME; + + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + GsApp *runtime = gs_app_get_runtime (app); + + if (runtime != NULL) + gs_app_list_add (runtimes_list, runtime); + } + + if (gs_app_list_length (runtimes_list) > 0 && runtimes_flags != 0) { + data->n_pending_recursions++; + run_refine_internal_async (self, plugin_loader, + runtimes_list, runtimes_flags, + cancellable, recursive_internal_refine_cb, + g_object_ref (task)); + } + } + + /* also do related packages one layer deep */ + if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED) { + g_autoptr(GsAppList) related_list = gs_app_list_new (); + GsPluginRefineFlags related_flags = flags; + + related_flags &= ~GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED; + + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + GsAppList *related = gs_app_get_related (app); + for (guint j = 0; j < gs_app_list_length (related); j++) { + GsApp *app2 = gs_app_list_index (related, j); + g_debug ("refining related: %s[%s]", + gs_app_get_id (app2), + gs_app_get_source_default (app2)); + gs_app_list_add (related_list, app2); + } + } + + if (gs_app_list_length (related_list) > 0 && related_flags != 0) { + data->n_pending_recursions++; + run_refine_internal_async (self, plugin_loader, + related_list, related_flags, + cancellable, recursive_internal_refine_cb, + g_object_ref (task)); + } + } + + finish_refine_internal_recursion (task, NULL); +} + +static void +recursive_internal_refine_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (source_object); + g_autoptr(GTask) task = g_steal_pointer (&user_data); + g_autoptr(GError) local_error = NULL; + + run_refine_internal_finish (self, result, &local_error); + finish_refine_internal_recursion (task, g_steal_pointer (&local_error)); +} + +/* @error is (transfer full) if non-NULL */ +static void +finish_refine_internal_recursion (GTask *task, + GError *error) +{ + g_autoptr(GError) error_owned = g_steal_pointer (&error); + RefineInternalData *data = g_task_get_task_data (task); + + if (data->error == NULL && error_owned != NULL) { + data->error = g_steal_pointer (&error_owned); + } else if (error_owned != NULL) { + g_debug ("Additional error while refining: %s", error_owned->message); + } + + g_assert (data->n_pending_recursions > 0); + data->n_pending_recursions--; + + if (data->n_pending_recursions > 0) + return; + + /* The entire refine operation (and all its sub-operations and + * recursions) is complete. */ + if (data->error != NULL) + g_task_return_error (task, g_steal_pointer (&data->error)); + else + g_task_return_boolean (task, TRUE); +} + +static gboolean +run_refine_internal_finish (GsPluginJobRefine *self, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static gboolean +app_thaw_notify_idle (gpointer data) +{ + GsApp *app = GS_APP (data); + g_object_thaw_notify (G_OBJECT (app)); + g_object_unref (app); + return G_SOURCE_REMOVE; +} + +static void run_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data); +static void finish_run (GTask *task, + GsAppList *result_list); + +static void +gs_plugin_job_refine_run_async (GsPluginJob *job, + GsPluginLoader *plugin_loader, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (job); + g_autoptr(GTask) task = NULL; + g_autoptr(GsAppList) result_list = NULL; + + /* check required args */ + task = g_task_new (job, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_job_refine_run_async); + + /* Operate on a copy of the input list so we don’t modify it when + * resolving wildcards. */ + result_list = gs_app_list_copy (self->app_list); + g_task_set_task_data (task, g_object_ref (result_list), (GDestroyNotify) g_object_unref); + + /* nothing to do */ + if (self->flags == 0 || + gs_app_list_length (result_list) == 0) { + g_debug ("no refine flags set for transaction or app list is empty"); + finish_run (task, result_list); + return; + } + + /* freeze all apps */ + for (guint i = 0; i < gs_app_list_length (self->app_list); i++) { + GsApp *app = gs_app_list_index (self->app_list, i); + g_object_freeze_notify (G_OBJECT (app)); + } + + /* Start refining the apps. */ + run_refine_internal_async (self, plugin_loader, result_list, + self->flags, cancellable, + run_cb, g_steal_pointer (&task)); +} + +static void +run_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GsPluginJobRefine *self = GS_PLUGIN_JOB_REFINE (source_object); + g_autoptr(GTask) task = g_steal_pointer (&user_data); + GsAppList *result_list = g_task_get_task_data (task); + g_autoptr(GError) local_error = NULL; + + if (run_refine_internal_finish (self, result, &local_error)) { + /* remove any addons that have the same source as the parent app */ + for (guint i = 0; i < gs_app_list_length (result_list); i++) { + g_autoptr(GPtrArray) to_remove = g_ptr_array_new (); + GsApp *app = gs_app_list_index (result_list, i); + g_autoptr(GsAppList) addons = gs_app_dup_addons (app); + + /* find any apps with the same source */ + const gchar *pkgname_parent = gs_app_get_source_default (app); + if (pkgname_parent == NULL) + continue; + for (guint j = 0; addons != NULL && j < gs_app_list_length (addons); j++) { + GsApp *addon = gs_app_list_index (addons, j); + if (g_strcmp0 (gs_app_get_source_default (addon), + pkgname_parent) == 0) { + g_debug ("%s has the same pkgname of %s as %s", + gs_app_get_unique_id (app), + pkgname_parent, + gs_app_get_unique_id (addon)); + g_ptr_array_add (to_remove, addon); + } + } + + /* remove any addons with the same source */ + for (guint j = 0; j < to_remove->len; j++) { + GsApp *addon = g_ptr_array_index (to_remove, j); + gs_app_remove_addon (app, addon); + } + } + } + + /* now emit all the changed signals */ + for (guint i = 0; i < gs_app_list_length (self->app_list); i++) { + GsApp *app = gs_app_list_index (self->app_list, i); + g_idle_add (app_thaw_notify_idle, g_object_ref (app)); + } + + /* Delayed error handling. */ + if (local_error != NULL) { + gs_utils_error_convert_gio (&local_error); + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + finish_run (task, result_list); +} + +static void +finish_run (GTask *task, + GsAppList *result_list) +{ + GsPluginJobRefine *self = g_task_get_source_object (task); + g_autofree gchar *job_debug = NULL; + + /* Internal calls to #GsPluginJobRefine may want to do their own + * filtering, typically if the refine is being done as part of another + * plugin job. If so, only filter to remove wildcards. Wildcards should + * always be removed, as they should have been resolved as part of the + * refine; any remaining wildcards will never be resolved. + * + * If the flag is not specified, filter by a variety of indicators of + * what a ‘valid’ app is. */ + if (self->flags & GS_PLUGIN_REFINE_FLAGS_DISABLE_FILTERING) + gs_app_list_filter (result_list, app_is_non_wildcard, NULL); + else + gs_app_list_filter (result_list, app_is_valid_filter, self); + + /* show elapsed time */ + job_debug = gs_plugin_job_to_string (GS_PLUGIN_JOB (self)); + g_debug ("%s", job_debug); + + /* success */ + g_set_object (&self->result_list, result_list); + g_task_return_boolean (task, TRUE); +} + +static gboolean +gs_plugin_job_refine_run_finish (GsPluginJob *self, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static void +gs_plugin_job_refine_class_init (GsPluginJobRefineClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GsPluginJobClass *job_class = GS_PLUGIN_JOB_CLASS (klass); + + object_class->dispose = gs_plugin_job_refine_dispose; + object_class->constructed = gs_plugin_job_refine_constructed; + object_class->get_property = gs_plugin_job_refine_get_property; + object_class->set_property = gs_plugin_job_refine_set_property; + + job_class->run_async = gs_plugin_job_refine_run_async; + job_class->run_finish = gs_plugin_job_refine_run_finish; + + /** + * GsPluginJobRefine:app-list: + * + * List of #GsApps to refine. + * + * This will not change during the course of the operation. + * + * Since: 42 + */ + props[PROP_APP_LIST] = + g_param_spec_object ("app-list", "App List", + "List of GsApps to refine.", + GS_TYPE_APP_LIST, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + /** + * GsPluginJobRefine:flags: + * + * Flags to control what to refine. + * + * Since: 42 + */ + props[PROP_FLAGS] = + g_param_spec_flags ("flags", "Flags", + "Flags to control what to refine.", + GS_TYPE_PLUGIN_REFINE_FLAGS, GS_PLUGIN_REFINE_FLAGS_NONE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + g_object_class_install_properties (object_class, G_N_ELEMENTS (props), props); +} + +static void +gs_plugin_job_refine_init (GsPluginJobRefine *self) +{ +} + +/** + * gs_plugin_job_refine_new: + * @app_list: the list of #GsApps to refine + * @flags: flags to affect what is refined + * + * Create a new #GsPluginJobRefine for refining the given @app_list. + * + * Returns: (transfer full): a new #GsPluginJobRefine + * Since: 42 + */ +GsPluginJob * +gs_plugin_job_refine_new (GsAppList *app_list, + GsPluginRefineFlags flags) +{ + return g_object_new (GS_TYPE_PLUGIN_JOB_REFINE, + "app-list", app_list, + "flags", flags, + NULL); +} + +/** + * gs_plugin_job_refine_new_for_app: + * @app: the #GsApp to refine + * @flags: flags to affect what is refined + * + * Create a new #GsPluginJobRefine for refining the given @app. + * + * Returns: (transfer full): a new #GsPluginJobRefine + * Since: 42 + */ +GsPluginJob * +gs_plugin_job_refine_new_for_app (GsApp *app, + GsPluginRefineFlags flags) +{ + g_autoptr(GsAppList) list = gs_app_list_new (); + gs_app_list_add (list, app); + + return gs_plugin_job_refine_new (list, flags); +} + +/** + * gs_plugin_job_refine_get_result_list: + * @self: a #GsPluginJobRefine + * + * Get the full list of refined #GsApps. This includes apps created in place of + * wildcards, if wildcards were provided in the #GsAppList passed to + * gs_plugin_job_refine_new(). + * + * If this is called before the job is complete, %NULL will be returned. + * + * Returns: (transfer none) (nullable): the job results, or %NULL on error + * or if called before the job has completed + * Since: 42 + */ +GsAppList * +gs_plugin_job_refine_get_result_list (GsPluginJobRefine *self) +{ + g_return_val_if_fail (GS_IS_PLUGIN_JOB_REFINE (self), NULL); + + return self->result_list; +} |