/**
* gs_plugin_update_app:
*/
gboolean
gs_plugin_update_app (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(XdgAppInstalledRef) xref = 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;
/* install */
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
xref = xdg_app_installation_update (priv->installation,
XDG_APP_UPDATE_FLAGS_NONE,
gs_app_get_xdgapp_kind (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
gs_plugin_xdg_app_progress_cb, app,
cancellable, error);
if (xref == NULL) {
gs_app_set_state_recover (app);
return FALSE;
}
/* state is known */
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
return TRUE;
}
/**
* gs_plugin_refine_item_origin:
*/
static gboolean
gs_plugin_refine_item_origin (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) xremotes = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* already set */
if (gs_app_get_origin (app) != NULL)
return TRUE;
/* ensure metadata exists */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-origin");
if (!gs_plugin_refine_item_metadata (plugin, app, cancellable, error))
return FALSE;
/* find list of remotes */
g_debug ("looking for a remote for %s/%s/%s",
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app));
xremotes = xdg_app_installation_list_remotes (priv->installation,
cancellable,
error);
if (xremotes == NULL)
return FALSE;
for (i = 0; i < xremotes->len; i++) {
const gchar *remote_name;
XdgAppRemote *xremote = g_ptr_array_index (xremotes, i);
g_autoptr(XdgAppRemoteRef) xref = NULL;
remote_name = xdg_app_remote_get_name (xremote);
g_debug ("looking at remote %s", remote_name);
xref = xdg_app_installation_fetch_remote_ref_sync (priv->installation,
remote_name,
gs_app_get_xdgapp_kind (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
cancellable,
NULL);
if (xref != NULL) {
g_debug ("found remote %s", remote_name);
gs_app_set_origin (app, remote_name);
return TRUE;
}
}
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"Not found %s/%s/%s",
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app));
return FALSE;
}
/**
* gs_plugin_launch:
*/
gboolean
gs_plugin_launch (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *branch = 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;
branch = gs_app_get_xdgapp_branch (app);
if (branch == NULL)
branch = "master";
return xdg_app_installation_launch (priv->installation,
gs_app_get_xdgapp_name (app),
NULL,
branch,
NULL,
cancellable,
error);
}
/**
* gs_plugin_app_remove:
*/
gboolean
gs_plugin_app_remove (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* 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;
/* remove */
gs_app_set_state (app, AS_APP_STATE_REMOVING);
if (!xdg_app_installation_uninstall (priv->installation,
XDG_APP_REF_KIND_APP,
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
gs_plugin_xdg_app_progress_cb, app,
cancellable, error)) {
gs_app_set_state_recover (app);
return FALSE;
}
/* state is not known: we don't know if we can re-install this app */
gs_app_set_state (app, AS_APP_STATE_UNKNOWN);
return TRUE;
}
static void
reload_proxy_settings (GsPlugin *plugin, GCancellable *cancellable)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autofree gchar *proxy_http = NULL;
g_autofree gchar *proxy_ftp = NULL;
g_autoptr(GPermission) permission = NULL;
/* only if we can achieve the action *without* an auth dialog */
permission = gs_utils_get_permission ("org.freedesktop.packagekit."
"system-network-proxy-configure");
if (permission == NULL) {
g_debug ("not setting proxy as no permission");
return;
}
if (!g_permission_get_allowed (permission)) {
g_debug ("not setting proxy as no auth requested");
return;
}
proxy_http = get_proxy_http (plugin);
proxy_ftp = get_proxy_ftp (plugin);
g_debug ("Setting proxies (http: %s, ftp: %s)", proxy_http, proxy_ftp);
pk_control_set_proxy_async (priv->control,
proxy_http,
proxy_ftp,
cancellable,
set_proxy_cb,
plugin);
}
static gchar *
get_proxy_ftp (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GString *string = NULL;
guint port;
GDesktopProxyMode proxy_mode;
g_autofree gchar *host = NULL;
proxy_mode = g_settings_get_enum (priv->settings, "mode");
if (proxy_mode != G_DESKTOP_PROXY_MODE_MANUAL)
return NULL;
host = g_settings_get_string (priv->settings_ftp, "host");
if (host == NULL)
return NULL;
port = g_settings_get_int (priv->settings_ftp, "port");
if (port == 0)
return NULL;
/* make PackageKit proxy string */
string = g_string_new (host);
if (port > 0)
g_string_append_printf (string, ":%i", port);
return g_string_free (string, FALSE);
}
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) swlist = NULL;
g_autoptr(GError) error_local = NULL;
/* HINT: We also emit not-installed but available software here. */
swlist = li_manager_get_software_list (priv->mgr, &error_local);
if (error_local != NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to list software: %s",
error_local->message);
return FALSE;
}
for (i = 0; i < swlist->len; i++) {
g_autoptr(GsApp) app = NULL;
LiPkgInfo *pki = LI_PKG_INFO (g_ptr_array_index (swlist, i));
app = gs_plugin_app_from_pki (pki);
gs_app_list_add (list, app);
}
return TRUE;
}
static gboolean
set_timestamp (GsPlugin *plugin,
const gchar *type,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
char *error_msg = NULL;
gint result;
g_autofree gchar *statement = NULL;
statement = g_strdup_printf ("INSERT OR REPLACE INTO timestamps (key, value) "
"VALUES ('%s', '%" G_GINT64_FORMAT "');",
type,
g_get_real_time () / G_USEC_PER_SEC);
result = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);
if (result != SQLITE_OK) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"SQL error: %s", error_msg);
sqlite3_free (error_msg);
return FALSE;
}
return TRUE;
}
static gboolean
set_package_stats (GsPlugin *plugin,
const gchar *package_name,
Histogram *histogram,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
char *error_msg = NULL;
gint result;
g_autofree gchar *statement = NULL;
statement = g_strdup_printf ("INSERT OR REPLACE INTO review_stats (package_name, "
"one_star_count, two_star_count, three_star_count, "
"four_star_count, five_star_count) "
"VALUES ('%s', '%" G_GUINT64_FORMAT "', '%" G_GUINT64_FORMAT"', '%" G_GUINT64_FORMAT "', '%" G_GUINT64_FORMAT "', '%" G_GUINT64_FORMAT "');",
package_name, histogram->one_star_count, histogram->two_star_count,
histogram->three_star_count, histogram->four_star_count, histogram->five_star_count);
result = sqlite3_exec (priv->db, statement, NULL, NULL, &error_msg);
if (result != SQLITE_OK) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"SQL error: %s", error_msg);
sqlite3_free (error_msg);
return FALSE;
}
return TRUE;
}
/**
* gs_plugin_refine_item_commit:
*/
static gboolean
gs_plugin_refine_item_commit (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(AsProfileTask) ptask = NULL;
g_autoptr(XdgAppRemoteRef) xref_remote = NULL;
if (gs_app_get_xdgapp_commit (app) != NULL)
return TRUE;
if (gs_app_get_origin (app) == NULL) {
g_debug ("no origin got commit, so refining origin first");
if (!gs_plugin_refine_item_origin (plugin, app, cancellable, error))
return FALSE;
}
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::fetch-remote-ref");
xref_remote = xdg_app_installation_fetch_remote_ref_sync (priv->installation,
gs_app_get_origin (app),
gs_app_get_xdgapp_kind (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
cancellable,
error);
if (xref_remote == NULL)
return FALSE;
gs_app_set_xdgapp_commit (app, xdg_app_ref_get_commit (XDG_APP_REF (xref_remote)));
return TRUE;
}
static gboolean
gs_plugin_app_source_enable (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
ProgressData data;
g_autoptr(PkResults) results = NULL;
data.app = app;
data.plugin = plugin;
data.ptask = NULL;
/* do sync call */
gs_plugin_status_update (plugin, app, GS_PLUGIN_STATUS_WAITING);
results = pk_client_repo_enable (PK_CLIENT (priv->task),
gs_app_get_origin (app),
TRUE,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error)) {
gs_utils_error_add_unique_id (error, app);
return FALSE;
}
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *origin;
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) == 0)
return TRUE;
/* no provenance */
if (!gs_app_has_quirk (app, AS_APP_QUIRK_PROVENANCE))
return TRUE;
/* nothing to search */
if (priv->sources == NULL || priv->sources[0] == NULL)
return TRUE;
/* simple case */
origin = gs_app_get_origin (app);
if (origin != NULL && gs_utils_strv_fnmatch (priv->sources, origin))
gs_app_set_license (app, GS_APP_QUALITY_NORMAL, priv->license_id);
return TRUE;
}
gboolean
gs_plugin_setup (GsPlugin *plugin, GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* add source */
priv->cached_origin = gs_app_new (gs_plugin_get_name (plugin));
gs_app_set_kind (priv->cached_origin, AS_APP_KIND_SOURCE);
gs_app_set_bundle_kind (priv->cached_origin, AS_BUNDLE_KIND_CABINET);
/* add the source to the plugin cache which allows us to match the
* unique ID to a GsApp when creating an event */
gs_plugin_cache_add (plugin,
gs_app_get_unique_id (priv->cached_origin),
priv->cached_origin);
/* register D-Bus errors */
fwupd_error_quark ();
g_signal_connect (priv->client, "changed",
G_CALLBACK (gs_plugin_fwupd_changed_cb), plugin);
g_signal_connect (priv->client, "device-added",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-removed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-changed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "notify::percentage",
G_CALLBACK (gs_plugin_fwupd_notify_percentage_cb), plugin);
g_signal_connect (priv->client, "notify::status",
G_CALLBACK (gs_plugin_fwupd_notify_status_cb), plugin);
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *tmp;
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME) == 0)
return TRUE;
if (gs_app_get_origin_hostname (app) != NULL)
return TRUE;
/* ensure valid */
if (!gs_plugin_repos_setup (plugin, cancellable, error))
return FALSE;
/* find hostname */
if (gs_app_get_origin (app) == NULL)
return TRUE;
tmp = g_hash_table_lookup (priv->urls, gs_app_get_origin (app));
if (tmp != NULL)
gs_app_set_origin_hostname (app, tmp);
return TRUE;
}
static void
gs_plugin_fwupd_notify_status_cb (GObject *object,
GParamSpec *pspec,
GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* nothing in progress */
if (priv->app_current == NULL) {
g_debug ("fwupd status: %s",
fwupd_status_to_string (fwupd_client_get_status (priv->client)));
return;
}
g_debug ("fwupd status for %s: %s",
gs_app_get_unique_id (priv->app_current),
fwupd_status_to_string (fwupd_client_get_status (priv->client)));
switch (fwupd_client_get_status (priv->client)) {
case FWUPD_STATUS_DECOMPRESSING:
case FWUPD_STATUS_DEVICE_RESTART:
case FWUPD_STATUS_DEVICE_WRITE:
case FWUPD_STATUS_DEVICE_VERIFY:
gs_app_set_state (priv->app_current, AS_APP_STATE_INSTALLING);
break;
case FWUPD_STATUS_IDLE:
g_clear_object (&priv->app_current);
break;
default:
break;
}
}
static gboolean
gs_plugin_fwupd_modify_source (GsPlugin *plugin, GsApp *app, gboolean enabled,
GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *remote_id = gs_app_get_metadata_item (app, "fwupd::remote-id");
if (remote_id == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"not enough data for fwupd %s",
gs_app_get_unique_id (app));
return FALSE;
}
gs_app_set_state (app, enabled ?
AS_APP_STATE_INSTALLING : AS_APP_STATE_REMOVING);
if (!fwupd_client_modify_remote (priv->client,
remote_id,
"Enabled",
enabled ? "true" : "false",
cancellable,
error)) {
gs_app_set_state_recover (app);
return FALSE;
}
gs_app_set_state (app, enabled ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
return TRUE;
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_object_unref (priv->client);
g_ptr_array_unref (priv->devices);
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
if (priv->monitor != NULL)
g_object_unref (priv->monitor);
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_mutex_clear (&priv->client_mutex);
g_object_unref (priv->client);
}
static gboolean
gs_plugin_odrs_refine_ratings (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GArray *review_ratings;
gint rating;
g_autoptr(AsProfileTask) ptask = NULL;
/* profile */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"odrs::refine-ratings");
g_assert (ptask != NULL);
/* get ratings */
review_ratings = g_hash_table_lookup (priv->ratings,
gs_app_get_id (app));
if (review_ratings == NULL)
return TRUE;
gs_app_set_review_ratings (app, review_ratings);
/* find the wilson rating */
rating = gs_utils_get_wilson_rating (g_array_index (review_ratings, guint32, 1),
g_array_index (review_ratings, guint32, 2),
g_array_index (review_ratings, guint32, 3),
g_array_index (review_ratings, guint32, 4),
g_array_index (review_ratings, guint32, 5));
if (rating > 0)
gs_app_set_rating (app, rating);
return TRUE;
}
gboolean
gs_plugin_refresh (GsPlugin *plugin,
guint cache_age,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GPtrArray) remotes = NULL;
/* get the list of enabled remotes */
remotes = fwupd_client_get_remotes (priv->client, cancellable, error);
if (remotes == NULL)
return FALSE;
for (guint i = 0; i < remotes->len; i++) {
FwupdRemote *remote = g_ptr_array_index (remotes, i);
if (!fwupd_remote_get_enabled (remote))
continue;
if (fwupd_remote_get_kind (remote) == FWUPD_REMOTE_KIND_LOCAL)
continue;
if (!gs_plugin_fwupd_refresh_remote (plugin, remote, cache_age,
cancellable, error))
return FALSE;
}
return TRUE;
}
static gboolean
gs_plugin_fedora_distro_upgrades_refresh (GsPlugin *plugin,
guint cache_age,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* check cache age */
if (cache_age > 0) {
guint tmp;
g_autoptr(GFile) file = g_file_new_for_path (priv->cachefn);
tmp = gs_utils_get_file_age (file);
if (tmp < cache_age) {
g_debug ("%s is only %u seconds old",
priv->cachefn, tmp);
return TRUE;
}
}
/* download new file */
if (!gs_plugin_download_file (plugin, NULL,
FEDORA_PKGDB_COLLECTIONS_API_URI,
priv->cachefn,
cancellable,
error)) {
gs_utils_error_add_unique_id (error, priv->cached_origin);
return FALSE;
}
/* success */
return TRUE;
}
static GsApp *
snap_to_app (GsPlugin *plugin, SnapdSnap *snap)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GStrv common_ids;
g_autofree gchar *appstream_id = NULL;
g_autofree gchar *unique_id = NULL;
g_autoptr(GsApp) app = NULL;
SnapdConfinement confinement;
/* Get the AppStream ID from the snap, or generate a fallback one */
common_ids = snapd_snap_get_common_ids (snap);
if (g_strv_length (common_ids) == 1)
appstream_id = g_strdup (common_ids[0]);
else
appstream_id = g_strdup_printf ("io.snapcraft.%s-%s", snapd_snap_get_name (snap), snapd_snap_get_id (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
unique_id = g_strdup_printf ("system/snap/*/desktop/%s/*", appstream_id);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
unique_id = g_strdup_printf ("system/snap/*/runtime/%s/*", appstream_id);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
unique_id = g_strdup_printf ("system/snap/*/*/%s/*", appstream_id);
break;
}
app = gs_plugin_cache_lookup (plugin, unique_id);
if (app == NULL) {
app = gs_app_new (NULL);
gs_app_set_from_unique_id (app, unique_id);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_metadata (app, "snap::name", snapd_snap_get_name (snap));
gs_plugin_cache_add (plugin, unique_id, app);
}
gs_app_set_management_plugin (app, "snap");
if (gs_app_get_kind (app) != AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
if (gs_plugin_check_distro_id (plugin, "ubuntu"))
gs_app_add_quirk (app, GS_APP_QUIRK_PROVENANCE);
confinement = snapd_snap_get_confinement (snap);
if (confinement != SNAPD_CONFINEMENT_UNKNOWN) {
GEnumClass *enum_class = g_type_class_ref (SNAPD_TYPE_CONFINEMENT);
gs_app_set_metadata (app, "snap::confinement", g_enum_get_value (enum_class, confinement)->value_nick);
g_type_class_unref (enum_class);
}
if (priv->system_confinement == SNAPD_SYSTEM_CONFINEMENT_STRICT && confinement == SNAPD_CONFINEMENT_STRICT)
gs_app_add_kudo (app, GS_APP_KUDO_SANDBOXED);
return g_steal_pointer (&app);
}
static gboolean
gs_plugin_add_sources_related (GsPlugin *plugin,
GHashTable *hash,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
GsApp *app;
GsApp *app_tmp;
PkBitfield filter;
ProgressData data;
const gchar *id;
gboolean ret = TRUE;
g_autoptr(GsAppList) installed = gs_app_list_new ();
g_autoptr(PkResults) results = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"packagekit::add-sources-related");
g_assert (ptask != NULL);
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_NEWEST,
PK_FILTER_ENUM_ARCH,
PK_FILTER_ENUM_NOT_COLLECTIONS,
-1);
results = pk_client_get_packages (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
ret = gs_plugin_packagekit_add_results (plugin,
installed,
results,
error);
if (!ret)
return FALSE;
for (i = 0; i < gs_app_list_length (installed); i++) {
g_auto(GStrv) split = NULL;
app = gs_app_list_index (installed, i);
split = pk_package_id_split (gs_app_get_source_id_default (app));
if (g_str_has_prefix (split[PK_PACKAGE_ID_DATA], "installed:")) {
id = split[PK_PACKAGE_ID_DATA] + 10;
app_tmp = g_hash_table_lookup (hash, id);
if (app_tmp != NULL) {
g_debug ("found package %s from %s",
gs_app_get_source_default (app), id);
gs_app_add_related (app_tmp, app);
}
}
}
return TRUE;
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
if (priv->cached_origin != NULL)
g_object_unref (priv->cached_origin);
g_object_unref (priv->client);
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_strfreev (priv->sources);
g_free (priv->license_id);
g_object_unref (priv->settings);
}
/**
* gs_plugin_refine_item_state:
*/
static gboolean
gs_plugin_refine_item_state (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) xrefs = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* already found */
if (gs_app_get_state (app) != AS_APP_STATE_UNKNOWN)
return TRUE;
/* need broken out metadata */
if (!gs_plugin_refine_item_metadata (plugin, app, cancellable, error))
return FALSE;
/* get apps and runtimes */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-action");
xrefs = xdg_app_installation_list_installed_refs (priv->installation,
cancellable, error);
if (xrefs == NULL)
return FALSE;
for (i = 0; i < xrefs->len; i++) {
XdgAppInstalledRef *xref = g_ptr_array_index (xrefs, i);
/* check xref is app */
if (!gs_plugin_xdg_app_is_xref (app, XDG_APP_REF(xref)))
continue;
/* mark as installed */
g_debug ("marking %s as installed with xdg-app",
gs_app_get_id (app));
gs_plugin_xdg_app_set_metadata_installed (app, xref);
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN)
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
}
/* anything not installed just check the remote is still present */
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN &&
gs_app_get_origin (app) != NULL) {
g_autoptr(XdgAppRemote) xremote = NULL;
xremote = xdg_app_installation_get_remote_by_name (priv->installation,
gs_app_get_origin (app),
cancellable, NULL);
if (xremote != NULL) {
g_debug ("marking %s as available with xdg-app",
gs_app_get_id (app));
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
}
}
/* success */
return TRUE;
}
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
PkBitfield filter;
PkRepoDetail *rd;
ProgressData data;
const gchar *id;
guint i;
g_autoptr(GHashTable) hash = NULL;
g_autoptr(PkResults) results = NULL;
g_autoptr(GPtrArray) array = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
/* ask PK for the repo details */
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_NOT_SOURCE,
PK_FILTER_ENUM_NOT_SUPPORTED,
-1);
results = pk_client_get_repo_list (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
array = pk_results_get_repo_detail_array (results);
for (i = 0; i < array->len; i++) {
g_autoptr(GsApp) app = NULL;
rd = g_ptr_array_index (array, i);
id = pk_repo_detail_get_id (rd);
app = gs_app_new (id);
gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_state (app, pk_repo_detail_get_enabled (rd) ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_list_add (list, app);
g_hash_table_insert (hash,
g_strdup (id),
(gpointer) app);
}
/* get every application on the system and add it as a related package
* if it matches */
return gs_plugin_add_sources_related (plugin, hash, cancellable, error);
}
static gboolean
gs_plugin_fwupd_install (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *device_id;
FwupdInstallFlags install_flags = 0;
GFile *local_file;
g_autofree gchar *filename = NULL;
/* 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);
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
if (!gs_plugin_download_file (plugin, app, uri, filename,
cancellable, error))
return FALSE;
}
/* limit to single device? */
device_id = gs_fwupd_app_get_device_id (app);
if (device_id == NULL)
device_id = FWUPD_DEVICE_ID_ANY;
/* set the last object */
g_set_object (&priv->app_current, app);
/* only offline supported */
if (gs_app_get_metadata_item (app, "fwupd::OnlyOffline") != NULL)
install_flags |= FWUPD_INSTALL_FLAG_OFFLINE;
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
if (!fwupd_client_install (priv->client, device_id,
filename, install_flags,
cancellable, error)) {
gs_plugin_fwupd_error_convert (error);
gs_app_set_state_recover (app);
return FALSE;
}
/* delete the file from the cache */
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
return g_file_delete (local_file, cancellable, error);
}
void
gs_plugin_destroy (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_free (priv->store_name);
g_clear_object (&priv->auth);
g_clear_pointer (&priv->store_snaps, g_hash_table_unref);
g_mutex_clear (&priv->store_snaps_lock);
}
