diff options
Diffstat (limited to 'lib/gs-app-list.c')
| -rw-r--r-- | lib/gs-app-list.c | 963 |
1 files changed, 963 insertions, 0 deletions
diff --git a/lib/gs-app-list.c b/lib/gs-app-list.c new file mode 100644 index 0000000..f2f599b --- /dev/null +++ b/lib/gs-app-list.c @@ -0,0 +1,963 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2013-2016 Richard Hughes <richard@hughsie.com> + * Copyright (C) 2017-2018 Kalev Lember <klember@redhat.com> + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +/** + * SECTION:gs-app-list + * @title: GsAppList + * @include: gnome-software.h + * @stability: Unstable + * @short_description: An application list + * + * These functions provide a refcounted list of #GsApp objects. + */ + +#include "config.h" + +#include <glib.h> + +#include "gs-app-private.h" +#include "gs-app-list-private.h" +#include "gs-app-collation.h" + +struct _GsAppList +{ + GObject parent_instance; + GPtrArray *array; + GMutex mutex; + guint size_peak; + GsAppListFlags flags; + AsAppState state; + guint progress; /* 0–100 inclusive, or %GS_APP_PROGRESS_UNKNOWN */ +}; + +G_DEFINE_TYPE (GsAppList, gs_app_list, G_TYPE_OBJECT) + +enum { + PROP_STATE = 1, + PROP_PROGRESS, + PROP_LAST +}; + +/** + * gs_app_list_get_state: + * @list: A #GsAppList + * + * Gets the state of the list. + * + * This method will only return a valid result if gs_app_list_add_flag() has + * been called with %GS_APP_LIST_FLAG_WATCH_APPS. + * + * Returns: the #AsAppState, e.g. %AS_APP_STATE_INSTALLED + * + * Since: 3.30 + **/ +AsAppState +gs_app_list_get_state (GsAppList *list) +{ + g_return_val_if_fail (GS_IS_APP_LIST (list), AS_APP_STATE_UNKNOWN); + return list->state; +} + +/** + * gs_app_list_get_progress: + * @list: A #GsAppList + * + * Gets the average percentage completion of all apps in the list. If any of the + * apps in the list has progress %GS_APP_PROGRESS_UNKNOWN, or if the app list + * is empty, %GS_APP_PROGRESS_UNKNOWN will be returned. + * + * This method will only return a valid result if gs_app_list_add_flag() has + * been called with %GS_APP_LIST_FLAG_WATCH_APPS. + * + * Returns: the percentage completion (0–100 inclusive), or %GS_APP_PROGRESS_UNKNOWN for unknown + * + * Since: 3.30 + **/ +guint +gs_app_list_get_progress (GsAppList *list) +{ + g_return_val_if_fail (GS_IS_APP_LIST (list), GS_APP_PROGRESS_UNKNOWN); + return list->progress; +} + +static void +gs_app_list_add_watched_for_app (GsAppList *list, GPtrArray *apps, GsApp *app) +{ + if (list->flags & GS_APP_LIST_FLAG_WATCH_APPS) + g_ptr_array_add (apps, app); + if (list->flags & GS_APP_LIST_FLAG_WATCH_APPS_ADDONS) { + GsAppList *list2 = gs_app_get_addons (app); + for (guint i = 0; i < gs_app_list_length (list2); i++) { + GsApp *app2 = gs_app_list_index (list2, i); + g_ptr_array_add (apps, app2); + } + } + if (list->flags & GS_APP_LIST_FLAG_WATCH_APPS_RELATED) { + GsAppList *list2 = gs_app_get_related (app); + for (guint i = 0; i < gs_app_list_length (list2); i++) { + GsApp *app2 = gs_app_list_index (list2, i); + g_ptr_array_add (apps, app2); + } + } +} + +static GPtrArray * +gs_app_list_get_watched_for_app (GsAppList *list, GsApp *app) +{ + GPtrArray *apps = g_ptr_array_new (); + gs_app_list_add_watched_for_app (list, apps, app); + return apps; +} + +static GPtrArray * +gs_app_list_get_watched (GsAppList *list) +{ + GPtrArray *apps = g_ptr_array_new (); + for (guint i = 0; i < list->array->len; i++) { + GsApp *app_tmp = g_ptr_array_index (list->array, i); + gs_app_list_add_watched_for_app (list, apps, app_tmp); + } + return apps; +} + +static void +gs_app_list_invalidate_progress (GsAppList *self) +{ + guint progress = 0; + g_autoptr(GPtrArray) apps = gs_app_list_get_watched (self); + + /* find the average percentage complete of the list */ + if (apps->len > 0) { + guint64 pc_cnt = 0; + gboolean unknown_seen = FALSE; + + for (guint i = 0; i < apps->len; i++) { + GsApp *app_tmp = g_ptr_array_index (apps, i); + guint app_progress = gs_app_get_progress (app_tmp); + + if (app_progress == GS_APP_PROGRESS_UNKNOWN) { + unknown_seen = TRUE; + break; + } + pc_cnt += gs_app_get_progress (app_tmp); + } + + progress = (!unknown_seen) ? pc_cnt / apps->len : GS_APP_PROGRESS_UNKNOWN; + } else { + progress = GS_APP_PROGRESS_UNKNOWN; + } + + if (self->progress != progress) { + self->progress = progress; + g_object_notify (G_OBJECT (self), "progress"); + } +} + +static void +gs_app_list_invalidate_state (GsAppList *self) +{ + AsAppState state = AS_APP_STATE_UNKNOWN; + g_autoptr(GPtrArray) apps = gs_app_list_get_watched (self); + + /* find any action state of the list */ + for (guint i = 0; i < apps->len; i++) { + GsApp *app_tmp = g_ptr_array_index (apps, i); + AsAppState state_tmp = gs_app_get_state (app_tmp); + if (state_tmp == AS_APP_STATE_INSTALLING || + state_tmp == AS_APP_STATE_REMOVING) { + state = state_tmp; + break; + } + } + if (self->state != state) { + self->state = state; + g_object_notify (G_OBJECT (self), "state"); + } +} + +static void +gs_app_list_progress_notify_cb (GsApp *app, GParamSpec *pspec, GsAppList *self) +{ + gs_app_list_invalidate_progress (self); +} + +static void +gs_app_list_state_notify_cb (GsApp *app, GParamSpec *pspec, GsAppList *self) +{ + gs_app_list_invalidate_state (self); +} + +static void +gs_app_list_maybe_watch_app (GsAppList *list, GsApp *app) +{ + g_autoptr(GPtrArray) apps = gs_app_list_get_watched_for_app (list, app); + for (guint i = 0; i < apps->len; i++) { + GsApp *app_tmp = g_ptr_array_index (apps, i); + g_signal_connect_object (app_tmp, "notify::progress", + G_CALLBACK (gs_app_list_progress_notify_cb), + list, 0); + g_signal_connect_object (app_tmp, "notify::state", + G_CALLBACK (gs_app_list_state_notify_cb), + list, 0); + } +} + +static void +gs_app_list_maybe_unwatch_app (GsAppList *list, GsApp *app) +{ + g_autoptr(GPtrArray) apps = gs_app_list_get_watched_for_app (list, app); + for (guint i = 0; i < apps->len; i++) { + GsApp *app_tmp = g_ptr_array_index (apps, i); + g_signal_handlers_disconnect_by_data (app_tmp, list); + } +} + +/** + * gs_app_list_get_size_peak: + * @list: A #GsAppList + * + * Returns the largest size the list has ever been. + * + * Returns: integer + * + * Since: 3.24 + **/ +guint +gs_app_list_get_size_peak (GsAppList *list) +{ + return list->size_peak; +} + +static GsApp * +gs_app_list_lookup_safe (GsAppList *list, const gchar *unique_id) +{ + for (guint i = 0; i < list->array->len; i++) { + GsApp *app = g_ptr_array_index (list->array, i); + if (as_utils_unique_id_equal (gs_app_get_unique_id (app), unique_id)) + return app; + } + return NULL; +} + +/** + * gs_app_list_lookup: + * @list: A #GsAppList + * @unique_id: A unique_id + * + * Finds the first matching application in the list using the usual wildcard + * rules allowed in unique_ids. + * + * Returns: (transfer none): a #GsApp, or %NULL if not found + * + * Since: 3.22 + **/ +GsApp * +gs_app_list_lookup (GsAppList *list, const gchar *unique_id) +{ + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&list->mutex); + return gs_app_list_lookup_safe (list, unique_id); +} + +/** + * gs_app_list_has_flag: + * @list: A #GsAppList + * @flag: A flag to test, e.g. %GS_APP_LIST_FLAG_IS_TRUNCATED + * + * Gets if a specific flag is set. + * + * Returns: %TRUE if the flag is set + * + * Since: 3.24 + **/ +gboolean +gs_app_list_has_flag (GsAppList *list, GsAppListFlags flag) +{ + return (list->flags & flag) > 0; +} + +/** + * gs_app_list_add_flag: + * @list: A #GsAppList + * @flag: A flag to test, e.g. %GS_APP_LIST_FLAG_IS_TRUNCATED + * + * Gets if a specific flag is set. + * + * Returns: %TRUE if the flag is set + * + * Since: 3.30 + **/ +void +gs_app_list_add_flag (GsAppList *list, GsAppListFlags flag) +{ + if (list->flags & flag) + return; + list->flags |= flag; + + /* turn this on for existing apps */ + for (guint i = 0; i < list->array->len; i++) { + GsApp *app = g_ptr_array_index (list->array, i); + gs_app_list_maybe_watch_app (list, app); + } +} + +static gboolean +gs_app_list_check_for_duplicate (GsAppList *list, GsApp *app) +{ + GsApp *app_old; + const gchar *id; + + /* adding a wildcard */ + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) { + for (guint i = 0; i < list->array->len; i++) { + GsApp *app_tmp = g_ptr_array_index (list->array, i); + if (!gs_app_has_quirk (app_tmp, GS_APP_QUIRK_IS_WILDCARD)) + continue; + /* not adding exactly the same wildcard */ + if (g_strcmp0 (gs_app_get_unique_id (app_tmp), + gs_app_get_unique_id (app)) == 0) + return FALSE; + } + return TRUE; + } + + /* does not exist */ + id = gs_app_get_unique_id (app); + if (id == NULL) { + for (guint i = 0; i < list->array->len; i++) { + GsApp *app_tmp = g_ptr_array_index (list->array, i); + if (app_tmp == app) + return FALSE; + } + /* not much else we can do... */ + return TRUE; + } + + /* existing app is a wildcard */ + app_old = gs_app_list_lookup_safe (list, id); + if (app_old == NULL) + return TRUE; + if (gs_app_has_quirk (app_old, GS_APP_QUIRK_IS_WILDCARD)) + return TRUE; + + /* already exists */ + return FALSE; +} + +typedef enum { + GS_APP_LIST_ADD_FLAG_NONE = 0, + GS_APP_LIST_ADD_FLAG_CHECK_FOR_DUPE = 1 << 0, + GS_APP_LIST_ADD_FLAG_LAST +} GsAppListAddFlag; + +static void +gs_app_list_add_safe (GsAppList *list, GsApp *app, GsAppListAddFlag flag) +{ + const gchar *id; + + /* check for duplicate */ + if ((flag & GS_APP_LIST_ADD_FLAG_CHECK_FOR_DUPE) > 0 && + !gs_app_list_check_for_duplicate (list, app)) + return; + + /* if we're lazy-loading the ID then we can't use the ID hash */ + id = gs_app_get_unique_id (app); + if (id == NULL) { + gs_app_list_maybe_watch_app (list, app); + g_ptr_array_add (list->array, g_object_ref (app)); + return; + } + + /* just use the ref */ + gs_app_list_maybe_watch_app (list, app); + g_ptr_array_add (list->array, g_object_ref (app)); + + /* update the historical max */ + if (list->array->len > list->size_peak) + list->size_peak = list->array->len; +} + +/** + * gs_app_list_add: + * @list: A #GsAppList + * @app: A #GsApp + * + * If the application does not already exist in the list then it is added, + * incrementing the reference count. + * If the application already exists then a warning is printed to the console. + * + * Applications that have the application ID lazy-loaded will always be added + * to the list, and to clean these up the plugin loader will also call the + * gs_app_list_filter_duplicates() method when all plugins have run. + * + * Since: 3.22 + **/ +void +gs_app_list_add (GsAppList *list, GsApp *app) +{ + g_autoptr(GMutexLocker) locker = NULL; + g_return_if_fail (GS_IS_APP_LIST (list)); + g_return_if_fail (GS_IS_APP (app)); + locker = g_mutex_locker_new (&list->mutex); + gs_app_list_add_safe (list, app, GS_APP_LIST_ADD_FLAG_CHECK_FOR_DUPE); + + /* recalculate global state */ + gs_app_list_invalidate_state (list); + gs_app_list_invalidate_progress (list); +} + +/** + * gs_app_list_remove: + * @list: A #GsAppList + * @app: A #GsApp + * + * Removes an application from the list. If the application does not exist the + * request is ignored. + * + * Since: 3.22 + **/ +void +gs_app_list_remove (GsAppList *list, GsApp *app) +{ + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + g_return_if_fail (GS_IS_APP (app)); + + locker = g_mutex_locker_new (&list->mutex); + g_ptr_array_remove (list->array, app); + gs_app_list_maybe_unwatch_app (list, app); + + /* recalculate global state */ + gs_app_list_invalidate_state (list); + gs_app_list_invalidate_progress (list); +} + +/** + * gs_app_list_add_list: + * @list: A #GsAppList + * @donor: Another #GsAppList + * + * Adds all the applications in @donor to @list. + * + * Since: 3.22 + **/ +void +gs_app_list_add_list (GsAppList *list, GsAppList *donor) +{ + guint i; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + g_return_if_fail (GS_IS_APP_LIST (donor)); + g_return_if_fail (list != donor); + + locker = g_mutex_locker_new (&list->mutex); + + /* add each app */ + for (i = 0; i < donor->array->len; i++) { + GsApp *app = gs_app_list_index (donor, i); + gs_app_list_add_safe (list, app, GS_APP_LIST_ADD_FLAG_CHECK_FOR_DUPE); + } + + /* recalculate global state */ + gs_app_list_invalidate_state (list); + gs_app_list_invalidate_progress (list); +} + +/** + * gs_app_list_index: + * @list: A #GsAppList + * @idx: An index into the list + * + * Gets an application at a specific position in the list. + * + * Returns: (transfer none): a #GsApp, or %NULL if invalid + * + * Since: 3.22 + **/ +GsApp * +gs_app_list_index (GsAppList *list, guint idx) +{ + return GS_APP (g_ptr_array_index (list->array, idx)); +} + +/** + * gs_app_list_length: + * @list: A #GsAppList + * + * Gets the length of the application list. + * + * Returns: Integer + * + * Since: 3.22 + **/ +guint +gs_app_list_length (GsAppList *list) +{ + g_return_val_if_fail (GS_IS_APP_LIST (list), 0); + return list->array->len; +} + +static void +gs_app_list_remove_all_safe (GsAppList *list) +{ + for (guint i = 0; i < list->array->len; i++) { + GsApp *app = g_ptr_array_index (list->array, i); + gs_app_list_maybe_unwatch_app (list, app); + } + g_ptr_array_set_size (list->array, 0); + gs_app_list_invalidate_state (list); + gs_app_list_invalidate_progress (list); +} + +/** + * gs_app_list_remove_all: + * @list: A #GsAppList + * + * Removes all applications from the list. + * + * Since: 3.22 + **/ +void +gs_app_list_remove_all (GsAppList *list) +{ + g_autoptr(GMutexLocker) locker = NULL; + g_return_if_fail (GS_IS_APP_LIST (list)); + locker = g_mutex_locker_new (&list->mutex); + gs_app_list_remove_all_safe (list); +} + +/** + * gs_app_list_filter: + * @list: A #GsAppList + * @func: A #GsAppListFilterFunc + * @user_data: the user pointer to pass to @func + * + * If func() returns TRUE for the GsApp, then the app is kept. + * + * Since: 3.22 + **/ +void +gs_app_list_filter (GsAppList *list, GsAppListFilterFunc func, gpointer user_data) +{ + guint i; + GsApp *app; + g_autoptr(GsAppList) old = NULL; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + g_return_if_fail (func != NULL); + + locker = g_mutex_locker_new (&list->mutex); + + /* deep copy to a temp list and clear the current one */ + old = gs_app_list_copy (list); + gs_app_list_remove_all_safe (list); + + /* see if any of the apps need filtering */ + for (i = 0; i < old->array->len; i++) { + app = gs_app_list_index (old, i); + if (func (app, user_data)) + gs_app_list_add_safe (list, app, GS_APP_LIST_ADD_FLAG_NONE); + } +} + +typedef struct { + GsAppListSortFunc func; + gpointer user_data; +} GsAppListSortHelper; + +static gint +gs_app_list_sort_cb (gconstpointer a, gconstpointer b, gpointer user_data) +{ + GsApp *app1 = GS_APP (*(GsApp **) a); + GsApp *app2 = GS_APP (*(GsApp **) b); + GsAppListSortHelper *helper = (GsAppListSortHelper *) user_data; + return helper->func (app1, app2, user_data); +} + +/** + * gs_app_list_sort: + * @list: A #GsAppList + * @func: A #GCompareFunc + * @user_data: user data to pass to @func + * + * Sorts the application list. + * + * Since: 3.22 + **/ +void +gs_app_list_sort (GsAppList *list, GsAppListSortFunc func, gpointer user_data) +{ + g_autoptr(GMutexLocker) locker = NULL; + GsAppListSortHelper helper; + g_return_if_fail (GS_IS_APP_LIST (list)); + locker = g_mutex_locker_new (&list->mutex); + helper.func = func; + helper.user_data = user_data; + g_ptr_array_sort_with_data (list->array, gs_app_list_sort_cb, &helper); +} + +/** + * gs_app_list_truncate: + * @list: A #GsAppList + * @length: the new length + * + * Truncates the application list. It is an error if @length is larger than the + * size of the list. + * + * Since: 3.24 + **/ +void +gs_app_list_truncate (GsAppList *list, guint length) +{ + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + g_return_if_fail (length <= list->array->len); + + /* mark this list as unworthy */ + list->flags |= GS_APP_LIST_FLAG_IS_TRUNCATED; + + /* everything */ + if (length == 0) { + gs_app_list_remove_all (list); + return; + } + + /* remove the apps in the positions larger than the length */ + locker = g_mutex_locker_new (&list->mutex); + g_ptr_array_set_size (list->array, length); +} + +static gint +gs_app_list_randomize_cb (gconstpointer a, gconstpointer b, gpointer user_data) +{ + GsApp *app1 = GS_APP (*(GsApp **) a); + GsApp *app2 = GS_APP (*(GsApp **) b); + const gchar *k1; + const gchar *k2; + g_autofree gchar *key = NULL; + + key = g_strdup_printf ("Plugin::sort-key[%p]", user_data); + k1 = gs_app_get_metadata_item (app1, key); + k2 = gs_app_get_metadata_item (app2, key); + return g_strcmp0 (k1, k2); +} + +/** + * gs_app_list_randomize: + * @list: A #GsAppList + * + * Randomize the order of the list, but don't change the order until + * the next day. + * + * Since: 3.22 + **/ +void +gs_app_list_randomize (GsAppList *list) +{ + guint i; + GRand *rand; + GsApp *app; + gchar sort_key[] = { '\0', '\0', '\0', '\0' }; + g_autoptr(GDateTime) date = NULL; + g_autofree gchar *key = NULL; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + + locker = g_mutex_locker_new (&list->mutex); + + /* mark this list as random */ + list->flags |= GS_APP_LIST_FLAG_IS_RANDOMIZED; + + key = g_strdup_printf ("Plugin::sort-key[%p]", list); + rand = g_rand_new (); + date = g_date_time_new_now_utc (); + g_rand_set_seed (rand, (guint32) g_date_time_get_day_of_year (date)); + for (i = 0; i < gs_app_list_length (list); i++) { + app = gs_app_list_index (list, i); + sort_key[0] = (gchar) g_rand_int_range (rand, (gint32) 'A', (gint32) 'Z'); + sort_key[1] = (gchar) g_rand_int_range (rand, (gint32) 'A', (gint32) 'Z'); + sort_key[2] = (gchar) g_rand_int_range (rand, (gint32) 'A', (gint32) 'Z'); + gs_app_set_metadata (app, key, sort_key); + } + g_ptr_array_sort_with_data (list->array, gs_app_list_randomize_cb, list); + for (i = 0; i < gs_app_list_length (list); i++) { + app = gs_app_list_index (list, i); + gs_app_set_metadata (app, key, NULL); + } + g_rand_free (rand); +} + +static gboolean +gs_app_list_filter_app_is_better (GsApp *app, GsApp *found, GsAppListFilterFlags flags) +{ + /* optional 1st layer sort */ + if ((flags & GS_APP_LIST_FILTER_FLAG_PREFER_INSTALLED) > 0) { + if (gs_app_is_installed (app) && !gs_app_is_installed (found)) + return TRUE; + if (!gs_app_is_installed (app) && gs_app_is_installed (found)) + return FALSE; + } + + /* 2nd layer, priority and bundle kind */ + if (gs_app_compare_priority (app, found) < 0) + return TRUE; + + /* assume is worse */ + return FALSE; +} + +static GPtrArray * +gs_app_list_filter_app_get_keys (GsApp *app, GsAppListFilterFlags flags) +{ + GPtrArray *keys = g_ptr_array_new_with_free_func (g_free); + g_autoptr(GString) key = NULL; + + /* just use the unique ID */ + if (flags == GS_APP_LIST_FILTER_FLAG_NONE) { + if (gs_app_get_unique_id (app) != NULL) + g_ptr_array_add (keys, g_strdup (gs_app_get_unique_id (app))); + return keys; + } + + /* use the ID and any provides */ + if (flags & GS_APP_LIST_FILTER_FLAG_KEY_ID_PROVIDES) { + GPtrArray *provides = gs_app_get_provides (app); + g_ptr_array_add (keys, g_strdup (gs_app_get_id (app))); + for (guint i = 0; i < provides->len; i++) { + AsProvide *prov = g_ptr_array_index (provides, i); + if (as_provide_get_kind (prov) != AS_PROVIDE_KIND_ID) + continue; + g_ptr_array_add (keys, g_strdup (as_provide_get_value (prov))); + } + return keys; + } + + /* specific compound type */ + key = g_string_new (NULL); + if (flags & GS_APP_LIST_FILTER_FLAG_KEY_ID) { + const gchar *tmp = gs_app_get_id (app); + if (tmp != NULL) + g_string_append (key, gs_app_get_id (app)); + } + if (flags & GS_APP_LIST_FILTER_FLAG_KEY_SOURCE) { + const gchar *tmp = gs_app_get_source_default (app); + if (tmp != NULL) + g_string_append_printf (key, ":%s", tmp); + } + if (flags & GS_APP_LIST_FILTER_FLAG_KEY_VERSION) { + const gchar *tmp = gs_app_get_version (app); + if (tmp != NULL) + g_string_append_printf (key, ":%s", tmp); + } + if (key->len == 0) + return keys; + g_ptr_array_add (keys, g_string_free (g_steal_pointer (&key), FALSE)); + return keys; +} + +/** + * gs_app_list_filter_duplicates: + * @list: A #GsAppList + * @flags: a #GsAppListFilterFlags, e.g. GS_APP_LIST_FILTER_KEY_ID + * + * Filter any duplicate applications from the list. + * + * Since: 3.22 + **/ +void +gs_app_list_filter_duplicates (GsAppList *list, GsAppListFilterFlags flags) +{ + g_autoptr(GHashTable) hash = NULL; + g_autoptr(GHashTable) kept_apps = NULL; + g_autoptr(GsAppList) old = NULL; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_APP_LIST (list)); + + locker = g_mutex_locker_new (&list->mutex); + + /* a hash table to hold apps with unique app ids */ + hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); + /* a hash table containing apps we want to keep */ + kept_apps = g_hash_table_new (g_direct_hash, g_direct_equal); + + for (guint i = 0; i < list->array->len; i++) { + GsApp *app = gs_app_list_index (list, i); + GsApp *found = NULL; + g_autoptr(GPtrArray) keys = NULL; + + /* get all the keys used to identify this app */ + keys = gs_app_list_filter_app_get_keys (app, flags); + for (guint j = 0; j < keys->len; j++) { + const gchar *key = g_ptr_array_index (keys, j); + found = g_hash_table_lookup (hash, key); + if (found != NULL) + break; + } + + /* new app */ + if (found == NULL) { + for (guint j = 0; j < keys->len; j++) { + const gchar *key = g_ptr_array_index (keys, j); + g_hash_table_insert (hash, g_strdup (key), app); + } + g_hash_table_add (kept_apps, app); + continue; + } + + /* better? */ + if (flags != GS_APP_LIST_FILTER_FLAG_NONE) { + if (gs_app_list_filter_app_is_better (app, found, flags)) { + for (guint j = 0; j < keys->len; j++) { + const gchar *key = g_ptr_array_index (keys, j); + g_hash_table_insert (hash, g_strdup (key), app); + } + g_hash_table_remove (kept_apps, found); + g_hash_table_add (kept_apps, app); + continue; + } + continue; + } + continue; + } + + /* deep copy to a temp list and clear the current one */ + old = gs_app_list_copy (list); + gs_app_list_remove_all_safe (list); + + /* add back the apps we want to keep */ + for (guint i = 0; i < old->array->len; i++) { + GsApp *app = gs_app_list_index (old, i); + if (g_hash_table_contains (kept_apps, app)) + gs_app_list_add_safe (list, app, GS_APP_LIST_ADD_FLAG_NONE); + } +} + +/** + * gs_app_list_copy: + * @list: A #GsAppList + * + * Returns a deep copy of the application list. + * + * Returns: A newly allocated #GsAppList + * + * Since: 3.22 + **/ +GsAppList * +gs_app_list_copy (GsAppList *list) +{ + GsAppList *new; + guint i; + + g_return_val_if_fail (GS_IS_APP_LIST (list), NULL); + + new = gs_app_list_new (); + for (i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + gs_app_list_add_safe (new, app, GS_APP_LIST_ADD_FLAG_NONE); + } + return new; +} + +static void +gs_app_list_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + GsAppList *self = GS_APP_LIST (object); + switch (prop_id) { + case PROP_STATE: + g_value_set_uint (value, self->state); + break; + case PROP_PROGRESS: + g_value_set_uint (value, self->progress); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_app_list_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_app_list_finalize (GObject *object) +{ + GsAppList *list = GS_APP_LIST (object); + g_ptr_array_unref (list->array); + g_mutex_clear (&list->mutex); + G_OBJECT_CLASS (gs_app_list_parent_class)->finalize (object); +} + +static void +gs_app_list_class_init (GsAppListClass *klass) +{ + GParamSpec *pspec; + GObjectClass *object_class = G_OBJECT_CLASS (klass); + object_class->get_property = gs_app_list_get_property; + object_class->set_property = gs_app_list_set_property; + object_class->finalize = gs_app_list_finalize; + + /** + * GsAppList:state: + */ + pspec = g_param_spec_uint ("state", NULL, NULL, + AS_APP_STATE_UNKNOWN, + AS_APP_STATE_LAST, + AS_APP_STATE_UNKNOWN, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_STATE, pspec); + + /** + * GsAppList:progress: + * + * A percentage (0–100, inclusive) indicating the progress through the + * current task on this app list. The value may otherwise be + * %GS_APP_PROGRESS_UNKNOWN if the progress is unknown or has a wide + * confidence interval on any app, or if the app list is empty. + */ + pspec = g_param_spec_uint ("progress", NULL, NULL, + 0, GS_APP_PROGRESS_UNKNOWN, GS_APP_PROGRESS_UNKNOWN, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_PROGRESS, pspec); +} + +static void +gs_app_list_init (GsAppList *list) +{ + g_mutex_init (&list->mutex); + list->array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); +} + +/** + * gs_app_list_new: + * + * Creates a new list. + * + * Returns: A newly allocated #GsAppList + * + * Since: 3.22 + **/ +GsAppList * +gs_app_list_new (void) +{ + GsAppList *list; + list = g_object_new (GS_TYPE_APP_LIST, NULL); + return GS_APP_LIST (list); +} |