gboolean
gs_plugin_refine (GsPlugin *plugin,
GsAppList *list,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GsApp) app = NULL;
g_autoptr(GsAppList) os_updates = gs_app_list_new ();
/* not from get_updates() */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS) == 0)
return TRUE;
/* do we have any packages left that are not apps? */
for (guint i = 0; i < gs_app_list_length (list); i++) {
GsApp *app_tmp = gs_app_list_index (list, i);
if (gs_app_has_quirk (app_tmp, GS_APP_QUIRK_IS_WILDCARD))
continue;
if (gs_plugin_generic_updates_merge_os_update (app_tmp))
gs_app_list_add (os_updates, app_tmp);
}
if (gs_app_list_length (os_updates) == 0)
return TRUE;
/* create new meta object */
app = gs_plugin_generic_updates_get_os_update (plugin);
for (guint i = 0; i < gs_app_list_length (os_updates); i++) {
GsApp *app_tmp = gs_app_list_index (os_updates, i);
gs_app_add_related (app, app_tmp);
gs_app_list_remove (list, app_tmp);
}
gs_app_list_add (list, app);
return TRUE;
}
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
g_autoptr(GError) error_local = NULL;
g_auto(GStrv) package_ids = NULL;
/* get the id's if the file exists */
package_ids = pk_offline_get_prepared_ids (&error_local);
if (package_ids == NULL) {
if (g_error_matches (error_local,
PK_OFFLINE_ERROR,
PK_OFFLINE_ERROR_NO_DATA)) {
return TRUE;
}
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"Failed to get prepared IDs: %s",
error_local->message);
return FALSE;
}
/* add them to the new array */
for (i = 0; package_ids[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
g_auto(GStrv) split = NULL;
/* search in the cache */
app = gs_plugin_cache_lookup (plugin, package_ids[i]);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new app */
app = gs_app_new (NULL);
gs_app_add_quirk (app, AS_APP_QUIRK_NEEDS_REBOOT);
gs_app_set_management_plugin (app, "packagekit");
gs_app_add_source_id (app, package_ids[i]);
split = pk_package_id_split (package_ids[i]);
gs_app_add_source (app, split[PK_PACKAGE_ID_NAME]);
gs_app_set_update_version (app, split[PK_PACKAGE_ID_VERSION]);
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_size_download (app, 0);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, package_ids[i], app);
}
return TRUE;
}
/**
* gs_plugin_add_popular:
*/
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
guint i;
const gchar *apps[] = {
"org.gnome.Builder.desktop",
"org.gnome.Calculator.desktop",
"org.gnome.clocks.desktop",
"org.gnome.Dictionary.desktop",
"org.gnome.Documents.desktop",
"org.gnome.Evince.desktop",
"org.gnome.gedit.desktop",
"org.gnome.Maps.desktop",
"org.gnome.Weather.desktop",
NULL };
/* just add all */
for (i = 0; apps[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
app = gs_app_new (apps[i]);
gs_app_list_add (list, app);
}
return TRUE;
}
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;
}
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autoptr(SnapdClient) client = NULL;
g_autoptr(GPtrArray) snaps = NULL;
guint i;
client = get_client (plugin, error);
if (client == NULL)
return FALSE;
snaps = snapd_client_get_snaps_sync (client, SNAPD_GET_SNAPS_FLAGS_NONE, NULL, cancellable, error);
if (snaps == NULL) {
snapd_error_convert (error);
return FALSE;
}
for (i = 0; i < snaps->len; i++) {
SnapdSnap *snap = g_ptr_array_index (snaps, i);
g_autoptr(GsApp) app = NULL;
app = snap_to_app (plugin, snap);
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_url_to_app (GsPlugin *plugin,
GsAppList *list,
const gchar *url,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *scheme = NULL;
g_autofree gchar *path = NULL;
g_autoptr(GPtrArray) snaps = NULL;
g_autoptr(GsApp) app = NULL;
/* not us */
scheme = gs_utils_get_url_scheme (url);
if (g_strcmp0 (scheme, "snap") != 0)
return TRUE;
/* create app */
path = gs_utils_get_url_path (url);
snaps = find_snaps (plugin, SNAPD_FIND_FLAGS_SCOPE_WIDE | SNAPD_FIND_FLAGS_MATCH_NAME, NULL, path, cancellable, NULL);
if (snaps == NULL || snaps->len < 1)
return TRUE;
app = snap_to_app (plugin, g_ptr_array_index (snaps, 0));
gs_app_list_add (list, app);
return TRUE;
}
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
const gchar *apps[] = {
"org.gnome.Builder.desktop",
"org.gnome.Calculator.desktop",
"org.gnome.clocks.desktop",
"org.gnome.Dictionary.desktop",
"org.gnome.Documents.desktop",
"org.gnome.Evince.desktop",
"org.gnome.gedit.desktop",
"org.gnome.Maps.desktop",
"org.gnome.Weather.desktop",
NULL };
/* we've already got enough popular apps */
if (gs_app_list_length (list) >= 5)
return TRUE;
/* just add all */
g_debug ("using hardcoded as only %u apps", gs_app_list_length (list));
for (i = 0; apps[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
/* look in the cache */
app = gs_plugin_cache_lookup (plugin, apps[i]);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new */
app = gs_app_new (apps[i]);
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_set_metadata (app, "GnomeSoftware::Creator",
gs_plugin_get_name (plugin));
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, apps[i], app);
}
return TRUE;
}
gboolean
gs_plugin_add_featured (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GPtrArray) snaps = NULL;
SnapdSnap *snap;
g_autoptr(GsApp) app = NULL;
const gchar *banner_url = NULL, *icon_url = NULL;
g_autoptr(GString) background_css = NULL;
g_autofree gchar *css = NULL;
snaps = find_snaps (plugin, SNAPD_FIND_FLAGS_SCOPE_WIDE, "featured", NULL, cancellable, error);
if (snaps == NULL)
return FALSE;
if (snaps->len == 0)
return TRUE;
/* use first snap as the featured app */
snap = snaps->pdata[0];
app = snap_to_app (plugin, snap);
/* if has a screenshot called 'banner.png' or 'banner-icon.png' then use them for the banner */
banner_url = get_media_url (snap, is_banner_image);
icon_url = get_media_url (snap, is_banner_icon_image);
background_css = g_string_new ("");
if (icon_url != NULL)
g_string_append_printf (background_css,
"url('%s') left center / auto 100%% no-repeat, ",
icon_url);
else
g_string_append_printf (background_css,
"url('%s') left center / auto 100%% no-repeat, ",
snapd_snap_get_icon (snap));
if (banner_url != NULL)
g_string_append_printf (background_css,
"url('%s') center / cover no-repeat;",
banner_url);
else
g_string_append_printf (background_css, "#FFFFFF;");
css = g_strdup_printf ("border-color: #000000;\n"
"text-shadow: 0 1px 1px rgba(255,255,255,0.5);\n"
"color: #000000;\n"
"outline-offset: 0;\n"
"outline-color: alpha(#ffffff, 0.75);\n"
"outline-style: dashed;\n"
"outline-offset: 2px;\n"
"background: %s;",
background_css->str);
gs_app_set_metadata (app, "GnomeSoftware::FeatureTile-css", css);
gs_app_list_add (list, app);
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);
}
gboolean
gs_plugin_add_category_apps (GsPlugin *plugin,
GsCategory *category,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsCategory *c;
g_autoptr(GString) id = NULL;
const gchar *sections = NULL;
id = g_string_new ("");
for (c = category; c != NULL; c = gs_category_get_parent (c)) {
if (c != category)
g_string_prepend (id, "/");
g_string_prepend (id, gs_category_get_id (c));
}
if (strcmp (id->str, "games/featured") == 0)
sections = "games";
else if (strcmp (id->str, "audio-video/featured") == 0)
sections = "music;video";
else if (strcmp (id->str, "graphics/featured") == 0)
sections = "graphics";
else if (strcmp (id->str, "communication/featured") == 0)
sections = "social-networking";
else if (strcmp (id->str, "productivity/featured") == 0)
sections = "productivity;finance";
else if (strcmp (id->str, "developer-tools/featured") == 0)
sections = "developers";
else if (strcmp (id->str, "utilities/featured") == 0)
sections = "utilities";
if (sections != NULL) {
g_auto(GStrv) tokens = NULL;
int i;
tokens = g_strsplit (sections, ";", -1);
for (i = 0; tokens[i] != NULL; i++) {
g_autoptr(GPtrArray) snaps = NULL;
guint j;
snaps = find_snaps (plugin, SNAPD_FIND_FLAGS_SCOPE_WIDE, tokens[i], NULL, cancellable, error);
if (snaps == NULL)
return FALSE;
for (j = 0; j < snaps->len; j++) {
g_autoptr(GsApp) app = snap_to_app (plugin, g_ptr_array_index (snaps, j));
gs_app_list_add (list, app);
}
}
}
return TRUE;
}
gboolean
gs_plugin_add_featured (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
/* we've already got enough featured apps */
if (gs_app_list_length (list) >= 5)
return TRUE;
/* just add all */
g_debug ("using hardcoded as only %u apps", gs_app_list_length (list));
for (i = 0; myapps[i].id != NULL; i++) {
g_autoptr(GsApp) app = NULL;
/* look in the cache */
app = gs_plugin_cache_lookup (plugin, myapps[i].id);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new */
app = gs_app_new (myapps[i].id);
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_set_metadata (app, "GnomeSoftware::Creator",
gs_plugin_get_name (plugin));
gs_app_set_metadata (app, "GnomeSoftware::FeatureTile-css",
myapps[i].css);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, myapps[i].id, app);
}
return TRUE;
}
gboolean
gs_plugin_refine (GsPlugin *plugin,
GsAppList *list,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GsApp) app = NULL;
g_autoptr(GsAppList) os_updates = gs_app_list_new ();
/* not from get_updates() */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS) == 0)
return TRUE;
/* do we have any packages left that are not apps? */
for (guint i = 0; i < gs_app_list_length (list); i++) {
GsApp *app_tmp = gs_app_list_index (list, i);
if (gs_plugin_generic_updates_merge_os_update (app_tmp))
gs_app_list_add (os_updates, app_tmp);
}
if (gs_app_list_length (os_updates) == 0)
return TRUE;
/* create new meta object */
app = gs_plugin_generic_updates_get_os_update (plugin);
for (guint i = 0; i < gs_app_list_length (os_updates); i++) {
GsApp *app_tmp = gs_app_list_index (os_updates, i);
const gchar *id = gs_app_get_unique_id (app_tmp);
if (id == NULL)
id = gs_app_get_source_default (app_tmp);
g_debug ("moving %s to parent %s",
id, gs_app_get_unique_id (app));
gs_app_add_related (app, app_tmp);
gs_app_list_remove (list, app_tmp);
}
gs_app_list_add (list, app);
return TRUE;
}
/**
* gs_plugin_add_updates:
*/
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) xrefs = NULL;
/* get all the installed apps (no network I/O) */
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);
const gchar *commit;
const gchar *latest_commit;
g_autoptr(GsApp) app = NULL;
g_autoptr(GError) error_local = NULL;
/* check the application has already been downloaded */
commit = xdg_app_ref_get_commit (XDG_APP_REF (xref));
latest_commit = xdg_app_installed_ref_get_latest_commit (xref);
if (g_strcmp0 (commit, latest_commit) == 0) {
g_debug ("no downloaded update for %s",
xdg_app_ref_get_name (XDG_APP_REF (xref)));
continue;
}
/* we have an update to show */
g_debug ("%s has a downloaded update %s->%s",
xdg_app_ref_get_name (XDG_APP_REF (xref)),
commit, latest_commit);
app = gs_plugin_xdg_app_create_installed (plugin, xref, &error_local);
if (app == NULL) {
g_warning ("failed to add xdg-app: %s", error_local->message);
continue;
}
if (gs_app_get_state (app) == AS_APP_STATE_INSTALLED)
gs_app_set_state (app, AS_APP_STATE_UNKNOWN);
gs_app_set_state (app, AS_APP_STATE_UPDATABLE_LIVE);
gs_app_list_add (list, app);
}
return TRUE;
}
GsAppList *
gs_update_list_get_apps (GsUpdateList *update_list)
{
GsAppList *apps;
GList *l;
g_autoptr(GList) children = NULL;
apps = gs_app_list_new ();
children = gtk_container_get_children (GTK_CONTAINER (update_list));
for (l = children; l != NULL; l = l->next) {
GsAppRow *app_row = GS_APP_ROW (l->data);
gs_app_list_add (apps, gs_app_row_get_app (app_row));
}
return apps;
}
gboolean
gs_plugin_file_to_app (GsPlugin *plugin,
GsAppList *list,
GFile *file,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autofree gchar *content_type = NULL;
g_autofree gchar *filename = NULL;
g_autoptr(GPtrArray) devices = NULL;
const gchar *mimetypes[] = {
"application/vnd.ms-cab-compressed",
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;
/* get results */
filename = g_file_get_path (file);
devices = fwupd_client_get_details (priv->client,
filename,
cancellable,
error);
if (devices == NULL) {
gs_plugin_fwupd_error_convert (error);
return FALSE;
}
for (guint i = 0; i < devices->len; i++) {
FwupdDevice *dev = g_ptr_array_index (devices, i);
g_autoptr(GsApp) app = NULL;
/* create each app */
app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
/* we have no update view for local files */
gs_app_set_version (app, gs_app_get_update_version (app));
gs_app_set_description (app, GS_APP_QUALITY_NORMAL,
gs_app_get_update_details (app));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_search (GsPlugin *plugin,
gchar **values,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
for (i = 0; values[i] != NULL; i++) {
if (g_strcmp0 (values[i], "fotoshop") == 0) {
g_autoptr(GsApp) app = gs_app_new ("gimp.desktop");
gs_app_add_quirk (app, AS_APP_QUIRK_MATCH_ANY_PREFIX);
gs_app_list_add (list, app);
}
}
return TRUE;
}
/**
* gs_plugin_add_installed:
*/
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GError) error_md = NULL;
g_autoptr(GPtrArray) xrefs = NULL;
guint i;
/* if we've never ever run before, get the AppStream data */
if (!gs_plugin_refresh_appstream (plugin,
G_MAXUINT,
cancellable,
&error_md)) {
g_warning ("failed to get initial available data: %s",
error_md->message);
}
/* get apps and runtimes */
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);
g_autoptr(GError) error_local = NULL;
g_autoptr(GsApp) app = NULL;
/* only apps */
if (xdg_app_ref_get_kind (XDG_APP_REF (xref)) != XDG_APP_REF_KIND_APP)
continue;
app = gs_plugin_xdg_app_create_installed (plugin, xref, &error_local);
if (app == NULL) {
g_warning ("failed to add xdg-app: %s", error_local->message);
continue;
}
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GPtrArray) remotes = NULL;
/* find all 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);
g_autofree gchar *id = NULL;
g_autoptr(GsApp) app = NULL;
/* ignore these, they're built in */
if (fwupd_remote_get_kind (remote) != FWUPD_REMOTE_KIND_DOWNLOAD)
continue;
/* create something that we can use to enable/disable */
id = g_strdup_printf ("org.fwupd.%s.remote", fwupd_remote_get_id (remote));
app = gs_app_new (id);
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_state (app, fwupd_remote_get_enabled (remote) ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
gs_app_set_name (app, GS_APP_QUALITY_LOWEST,
fwupd_remote_get_title (remote));
#if FWUPD_CHECK_VERSION(1,0,7)
gs_app_set_agreement (app, fwupd_remote_get_agreement (remote));
#endif
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE,
fwupd_remote_get_metadata_uri (remote));
gs_app_set_metadata (app, "fwupd::remote-id",
fwupd_remote_get_id (remote));
gs_app_set_management_plugin (app, "fwupd");
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_updates_historical (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GError) error_local = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(FwupdDevice) dev = NULL;
/* get historical updates */
dev = fwupd_client_get_results (priv->client,
FWUPD_DEVICE_ID_ANY,
cancellable,
&error_local);
if (dev == NULL) {
if (g_error_matches (error_local,
FWUPD_ERROR,
FWUPD_ERROR_NOTHING_TO_DO))
return TRUE;
if (g_error_matches (error_local,
FWUPD_ERROR,
FWUPD_ERROR_NOT_FOUND))
return TRUE;
g_propagate_error (error, g_steal_pointer (&error_local));
gs_plugin_fwupd_error_convert (error);
return FALSE;
}
/* parse */
app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
if (app == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"failed to build result for %s",
fwupd_device_get_id (dev));
return FALSE;
}
gs_app_list_add (list, app);
return TRUE;
}
/**
* gs_plugin_add_sources:
*/
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GList **list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GPtrArray) xremotes = NULL;
guint i;
xremotes = xdg_app_installation_list_remotes (priv->installation,
cancellable,
error);
if (xremotes == NULL)
return FALSE;
for (i = 0; i < xremotes->len; i++) {
XdgAppRemote *xremote = g_ptr_array_index (xremotes, i);
g_autoptr(GsApp) app = NULL;
/* apps installed from bundles add their own remote that only
* can be used for updating that app only -- so hide them */
if (xdg_app_remote_get_noenumerate (xremote))
continue;
app = gs_app_new (xdg_app_remote_get_name (xremote));
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, AS_APP_STATE_INSTALLED);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
xdg_app_remote_get_name (xremote));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
xdg_app_remote_get_title (xremote));
gs_app_set_url (app,
AS_URL_KIND_HOMEPAGE,
xdg_app_remote_get_url (xremote));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_popular (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GPtrArray) snaps = NULL;
guint i;
snaps = find_snaps (plugin, SNAPD_FIND_FLAGS_SCOPE_WIDE, "featured", NULL, cancellable, error);
if (snaps == NULL)
return FALSE;
/* skip first snap - it is used as the featured app */
for (i = 1; i < snaps->len; i++) {
g_autoptr(GsApp) app = snap_to_app (plugin, g_ptr_array_index (snaps, i));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *macaroon = NULL;
g_auto(GStrv) discharges = NULL;
g_autoptr(JsonArray) result = NULL;
guint i;
get_macaroon (plugin, &macaroon, &discharges);
result = gs_snapd_list (macaroon, discharges, cancellable, error);
if (result == NULL)
return FALSE;
for (i = 0; i < json_array_get_length (result); i++) {
JsonObject *package = json_array_get_object_element (result, i);
g_autoptr(GsApp) app = NULL;
const gchar *status, *name;
status = json_object_get_string_member (package, "status");
if (g_strcmp0 (status, "active") != 0)
continue;
/* create a unique ID for deduplication, TODO: branch? */
name = json_object_get_string_member (package, "name");
app = gs_app_new (name);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_management_plugin (app, "snap");
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_REVIEWABLE);
refine_app (plugin, app, package, TRUE, cancellable);
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GList) updates = NULL;
GList *l;
g_autoptr(GError) error_local = NULL;
updates = li_manager_get_update_list (priv->mgr, &error_local);
if (error_local != NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to list updates: %s",
error_local->message);
return FALSE;
}
for (l = updates; l != NULL; l = l->next) {
LiPkgInfo *old_pki;
LiPkgInfo *new_pki;
g_autoptr(GsApp) app = NULL;
LiUpdateItem *uitem = LI_UPDATE_ITEM (l->data);
old_pki = li_update_item_get_installed_pkg (uitem);
new_pki = li_update_item_get_available_pkg (uitem);
app = gs_plugin_app_from_pki (old_pki);
gs_app_set_update_version (app,
li_pkg_info_get_version (new_pki));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_search (GsPlugin *plugin,
gchar **values,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *query = NULL;
g_autoptr(GPtrArray) snaps = NULL;
guint i;
query = g_strjoinv (" ", values);
snaps = find_snaps (plugin, SNAPD_FIND_FLAGS_SCOPE_WIDE, NULL, query, cancellable, error);
if (snaps == NULL)
return FALSE;
for (i = 0; i < snaps->len; i++) {
g_autoptr(GsApp) app = snap_to_app (plugin, g_ptr_array_index (snaps, i));
gs_app_list_add (list, app);
}
return TRUE;
}
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GError) error_local = NULL;
g_autoptr(GPtrArray) devices = NULL;
/* get current list of updates */
devices = fwupd_client_get_devices (priv->client, cancellable, &error_local);
if (devices == NULL) {
if (g_error_matches (error_local,
FWUPD_ERROR,
FWUPD_ERROR_NOTHING_TO_DO)) {
g_debug ("no devices");
return TRUE;
}
g_propagate_error (error, g_steal_pointer (&error_local));
gs_plugin_fwupd_error_convert (error);
return FALSE;
}
for (guint i = 0; i < devices->len; i++) {
FwupdDevice *dev = g_ptr_array_index (devices, i);
FwupdRelease *rel_newest;
g_autoptr(GError) error_local2 = NULL;
g_autoptr(GPtrArray) rels = NULL;
g_autoptr(GsApp) app = NULL;
/* locked device that needs unlocking */
if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_LOCKED)) {
app = gs_plugin_fwupd_new_app_from_device_raw (plugin, dev);
gs_fwupd_app_set_is_locked (app, TRUE);
gs_app_list_add (list, app);
continue;
}
/* not going to have results, so save a D-Bus round-trip */
if (!fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_SUPPORTED))
continue;
/* get the releases for this device and filter for validity */
rels = fwupd_client_get_upgrades (priv->client,
fwupd_device_get_id (dev),
cancellable, &error_local2);
if (rels == NULL) {
if (g_error_matches (error_local2,
FWUPD_ERROR,
FWUPD_ERROR_NOTHING_TO_DO)) {
g_debug ("no updates for %s", fwupd_device_get_id (dev));
continue;
}
if (g_error_matches (error_local2,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED)) {
g_debug ("not supported for %s", fwupd_device_get_id (dev));
continue;
}
g_warning ("failed to get upgrades for %s: %s]",
fwupd_device_get_id (dev),
error_local2->message);
continue;
}
/* normal device update */
rel_newest = g_ptr_array_index (rels, 0);
fwupd_device_add_release (dev, rel_newest);
app = gs_plugin_fwupd_new_app (plugin, dev, &error_local2);
if (app == NULL) {
g_debug ("%s", error_local2->message);
continue;
}
/* add update descriptions for all releases inbetween */
if (rels->len > 1) {
g_autoptr(GString) update_desc = g_string_new (NULL);
for (guint j = 0; j < rels->len; j++) {
FwupdRelease *rel = g_ptr_array_index (rels, j);
g_autofree gchar *desc = NULL;
if (fwupd_release_get_description (rel) == NULL)
continue;
desc = as_markup_convert (fwupd_release_get_description (rel),
AS_MARKUP_CONVERT_FORMAT_SIMPLE,
NULL);
if (desc == NULL)
continue;
g_string_append_printf (update_desc,
"Version %s:\n%s\n\n",
fwupd_release_get_version (rel),
desc);
}
if (update_desc->len > 2) {
g_string_truncate (update_desc, update_desc->len - 2);
gs_app_set_update_details (app, update_desc->str);
}
}
gs_app_list_add (list, app);
}
return TRUE;
}
/**
* 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;
}
gboolean
gs_plugin_add_unvoted_reviews (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint status_code;
guint i;
g_autofree gchar *uri = NULL;
g_autoptr(GHashTable) hash = NULL;
g_autoptr(GPtrArray) reviews = NULL;
g_autoptr(SoupMessage) msg = NULL;
/* create the GET data *with* the machine hash so we can later
* review the application ourselves */
uri = g_strdup_printf ("%s/moderate/%s/%s",
priv->review_server,
priv->user_hash,
gs_plugin_get_locale (plugin));
msg = soup_message_new (SOUP_METHOD_GET, uri);
status_code = soup_session_send_message (gs_plugin_get_soup_session (plugin), msg);
if (status_code != SOUP_STATUS_OK) {
if (!gs_plugin_odrs_parse_success (msg->response_body->data,
msg->response_body->length,
error))
return FALSE;
/* not sure what to do here */
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_DOWNLOAD_FAILED,
"status code invalid");
gs_utils_error_add_unique_id (error, priv->cached_origin);
return FALSE;
}
g_debug ("odrs returned: %s", msg->response_body->data);
reviews = gs_plugin_odrs_parse_reviews (plugin,
msg->response_body->data,
msg->response_body->length,
error);
if (reviews == NULL)
return FALSE;
/* look at all the reviews; faking application objects */
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_object_unref);
for (i = 0; i < reviews->len; i++) {
GsApp *app;
AsReview *review;
const gchar *app_id;
/* same app? */
review = g_ptr_array_index (reviews, i);
app_id = as_review_get_metadata_item (review, "app_id");
app = g_hash_table_lookup (hash, app_id);
if (app == NULL) {
app = gs_plugin_create_app_dummy (app_id);
gs_app_list_add (list, app);
g_hash_table_insert (hash, g_strdup (app_id), app);
}
gs_app_add_review (app, review);
}
return TRUE;
}
gboolean
gs_plugin_file_to_app (GsPlugin *plugin,
GsAppList *list,
GFile *file,
GCancellable *cancellable,
GError **error)
{
GsApp *app;
guint i;
g_autofree gchar *content_type = NULL;
g_autofree gchar *output = NULL;
g_auto(GStrv) argv = NULL;
g_auto(GStrv) tokens = NULL;
g_autoptr(GString) str = NULL;
const gchar *mimetypes[] = {
"application/vnd.debian.binary-package",
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;
/* exec sync */
argv = g_new0 (gchar *, 5);
argv[0] = g_strdup (DPKG_DEB_BINARY);
argv[1] = g_strdup ("--showformat=${Package}\\n"
"${Version}\\n"
"${Installed-Size}\\n"
"${Homepage}\\n"
"${Description}");
argv[2] = g_strdup ("-W");
argv[3] = g_file_get_path (file);
if (!g_spawn_sync (NULL, argv, NULL,
G_SPAWN_SEARCH_PATH | G_SPAWN_STDERR_TO_DEV_NULL,
NULL, NULL, &output, NULL, NULL, error)) {
gs_utils_error_convert_gio (error);
return FALSE;
}
/* parse output */
tokens = g_strsplit (output, "\n", 0);
if (g_strv_length (tokens) < 5) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"dpkg-deb output format incorrect:\n\"%s\"\n", output);
return FALSE;
}
/* create app */
app = gs_app_new (NULL);
gs_app_set_state (app, AS_APP_STATE_AVAILABLE_LOCAL);
gs_app_add_source (app, tokens[0]);
gs_app_set_name (app, GS_APP_QUALITY_LOWEST, tokens[0]);
gs_app_set_version (app, tokens[1]);
gs_app_set_size_installed (app, 1024 * g_ascii_strtoull (tokens[2], NULL, 10));
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE, tokens[3]);
gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, tokens[4]);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_metadata (app, "GnomeSoftware::Creator",
gs_plugin_get_name (plugin));
/* multiline text */
str = g_string_new ("");
for (i = 5; tokens[i] != NULL; i++) {
if (g_strcmp0 (tokens[i], " .") == 0) {
if (str->len > 0)
g_string_truncate (str, str->len - 1);
g_string_append (str, "\n");
continue;
}
g_strstrip (tokens[i]);
g_string_append_printf (str, "%s ", tokens[i]);
}
if (str->len > 0)
g_string_truncate (str, str->len - 1);
gs_app_set_description (app, GS_APP_QUALITY_LOWEST, str->str);
/* success */
gs_app_list_add (list, app);
return TRUE;
}
int
main (int argc, char **argv)
{
AsProfile *profile = NULL;
GOptionContext *context;
gboolean prefer_local = FALSE;
gboolean ret;
gboolean show_results = FALSE;
gboolean verbose = FALSE;
guint64 refine_flags = GS_PLUGIN_REFINE_FLAGS_DEFAULT;
gint i;
guint cache_age = 0;
gint repeat = 1;
int status = 0;
g_auto(GStrv) plugin_blacklist = NULL;
g_auto(GStrv) plugin_whitelist = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GsAppList) list = NULL;
g_autoptr(GPtrArray) categories = NULL;
g_autoptr(GsDebug) debug = gs_debug_new ();
g_autofree gchar *plugin_blacklist_str = NULL;
g_autofree gchar *plugin_whitelist_str = NULL;
g_autofree gchar *refine_flags_str = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GsPluginLoader) plugin_loader = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
const GOptionEntry options[] = {
{ "show-results", '\0', 0, G_OPTION_ARG_NONE, &show_results,
"Show the results for the action", NULL },
{ "refine-flags", '\0', 0, G_OPTION_ARG_STRING, &refine_flags_str,
"Set any refine flags required for the action", NULL },
{ "repeat", '\0', 0, G_OPTION_ARG_INT, &repeat,
"Repeat the action this number of times", NULL },
{ "cache-age", '\0', 0, G_OPTION_ARG_INT, &cache_age,
"Use this maximum cache age in seconds", NULL },
{ "prefer-local", '\0', 0, G_OPTION_ARG_NONE, &prefer_local,
"Prefer local file sources to AppStream", NULL },
{ "plugin-blacklist", '\0', 0, G_OPTION_ARG_STRING, &plugin_blacklist_str,
"Do not load specific plugins", NULL },
{ "plugin-whitelist", '\0', 0, G_OPTION_ARG_STRING, &plugin_whitelist_str,
"Only load specific plugins", NULL },
{ "verbose", '\0', 0, G_OPTION_ARG_NONE, &verbose,
"Show verbose debugging information", NULL },
{ NULL}
};
setlocale (LC_ALL, "");
g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, "GNOME Software Test Program");
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
ret = g_option_context_parse (context, &argc, &argv, &error);
if (!ret) {
g_print ("Failed to parse options: %s\n", error->message);
goto out;
}
if (verbose)
g_setenv ("GS_DEBUG", "1", TRUE);
/* prefer local sources */
if (prefer_local)
g_setenv ("GNOME_SOFTWARE_PREFER_LOCAL", "true", TRUE);
/* parse any refine flags */
refine_flags = gs_cmd_parse_refine_flags (refine_flags_str, &error);
if (refine_flags == G_MAXUINT64) {
g_print ("Flag unknown: %s\n", error->message);
goto out;
}
/* load plugins */
plugin_loader = gs_plugin_loader_new ();
profile = gs_plugin_loader_get_profile (plugin_loader);
ptask = as_profile_start_literal (profile, "GsCmd");
g_assert (ptask != NULL);
if (g_file_test (LOCALPLUGINDIR, G_FILE_TEST_EXISTS))
gs_plugin_loader_set_location (plugin_loader, LOCALPLUGINDIR);
if (plugin_whitelist_str != NULL)
plugin_whitelist = g_strsplit (plugin_whitelist_str, ",", -1);
if (plugin_blacklist_str != NULL)
plugin_blacklist = g_strsplit (plugin_blacklist_str, ",", -1);
ret = gs_plugin_loader_setup (plugin_loader,
plugin_whitelist,
plugin_blacklist,
GS_PLUGIN_FAILURE_FLAGS_NONE,
NULL,
&error);
if (!ret) {
g_print ("Failed to setup plugins: %s\n", error->message);
goto out;
}
gs_plugin_loader_dump_state (plugin_loader);
/* do action */
if (argc == 2 && g_strcmp0 (argv[1], "installed") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_installed (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 3 && g_strcmp0 (argv[1], "search") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_search (plugin_loader,
argv[2],
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 3 && g_strcmp0 (argv[1], "action-upgrade-download") == 0) {
app = gs_app_new (argv[2]);
gs_app_set_kind (app, AS_APP_KIND_OS_UPGRADE);
ret = gs_plugin_loader_app_action (plugin_loader,
app,
GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (ret)
gs_app_list_add (list, app);
} else if (argc == 3 && g_strcmp0 (argv[1], "refine") == 0) {
app = gs_app_new (argv[2]);
for (i = 0; i < repeat; i++) {
ret = gs_plugin_loader_app_refine (plugin_loader,
app,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (!ret)
break;
}
list = gs_app_list_new ();
gs_app_list_add (list, app);
} else if (argc == 3 && g_strcmp0 (argv[1], "launch") == 0) {
app = gs_app_new (argv[2]);
for (i = 0; i < repeat; i++) {
ret = gs_plugin_loader_app_action (plugin_loader,
app,
GS_PLUGIN_ACTION_LAUNCH,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (!ret)
break;
}
} else if (argc == 3 && g_strcmp0 (argv[1], "filename-to-app") == 0) {
file = g_file_new_for_path (argv[2]);
app = gs_plugin_loader_file_to_app (plugin_loader,
file,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (app == NULL) {
ret = FALSE;
} else {
list = gs_app_list_new ();
gs_app_list_add (list, app);
}
} else if (argc == 2 && g_strcmp0 (argv[1], "updates") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_updates (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 2 && g_strcmp0 (argv[1], "upgrades") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_distro_upgrades (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 2 && g_strcmp0 (argv[1], "sources") == 0) {
list = gs_plugin_loader_get_sources (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL)
ret = FALSE;
} else if (argc == 2 && g_strcmp0 (argv[1], "popular") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_popular (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 2 && g_strcmp0 (argv[1], "featured") == 0) {
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_featured (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 2 && g_strcmp0 (argv[1], "get-categories") == 0) {
for (i = 0; i < repeat; i++) {
if (categories != NULL)
g_ptr_array_unref (categories);
categories = gs_plugin_loader_get_categories (plugin_loader,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (categories == NULL) {
ret = FALSE;
break;
}
}
} else if (argc == 3 && g_strcmp0 (argv[1], "get-category-apps") == 0) {
g_autoptr(GsCategory) category = NULL;
g_autoptr(GsCategory) parent = NULL;
g_auto(GStrv) split = NULL;
split = g_strsplit (argv[2], "/", 2);
if (g_strv_length (split) == 1) {
category = gs_category_new (split[0]);
} else {
parent = gs_category_new (split[0]);
category = gs_category_new (split[1]);
gs_category_add_child (parent, category);
}
for (i = 0; i < repeat; i++) {
if (list != NULL)
g_object_unref (list);
list = gs_plugin_loader_get_category_apps (plugin_loader,
category,
refine_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL,
&error);
if (list == NULL) {
ret = FALSE;
break;
}
}
} else if (argc >= 2 && g_strcmp0 (argv[1], "refresh") == 0) {
GsPluginRefreshFlags refresh_flags;
refresh_flags = gs_cmd_refresh_flag_from_string (argv[2]);
ret = gs_plugin_loader_refresh (plugin_loader, cache_age,
refresh_flags,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
NULL, &error);
} else {
ret = FALSE;
g_set_error_literal (&error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Did not recognise option, use 'installed', "
"'updates', 'popular', 'get-categories', "
"'get-category-apps', 'filename-to-app', "
"'sources', 'refresh', 'launch' or 'search'");
}
if (!ret) {
g_print ("Failed: %s\n", error->message);
goto out;
}
if (show_results) {
if (list != NULL)
gs_cmd_show_results_apps (list);
if (categories != NULL)
gs_cmd_show_results_categories (categories);
}
out:
if (profile != NULL)
as_profile_dump (profile);
g_option_context_free (context);
return status;
}
static void
gs_page_app_installed_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
g_autoptr(GsPageHelper) helper = (GsPageHelper *) user_data;
GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (source);
GsPage *page = helper->page;
GsPagePrivate *priv = gs_page_get_instance_private (page);
gboolean ret;
g_autoptr(GError) error = NULL;
ret = gs_plugin_loader_job_action_finish (plugin_loader,
res,
&error);
if (g_error_matches (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_CANCELLED)) {
g_debug ("%s", error->message);
return;
}
if (!ret) {
/* try to authenticate then retry */
if (g_error_matches (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_AUTH_REQUIRED)) {
gs_page_authenticate (page,
helper->app,
gs_utils_get_error_value (error),
helper->cancellable,
gs_page_install_authenticate_cb,
helper);
g_steal_pointer (&helper);
return;
}
g_warning ("failed to install %s: %s",
gs_app_get_id (helper->app),
error->message);
return;
}
/* the single update needs system reboot, e.g. for firmware */
if (gs_app_has_quirk (helper->app, GS_APP_QUIRK_NEEDS_REBOOT)) {
g_autoptr(GsAppList) list = gs_app_list_new ();
gs_app_list_add (list, helper->app);
gs_utils_reboot_notify (list);
}
/* only show this if the window is not active */
if (gs_app_is_installed (helper->app) &&
helper->action == GS_PLUGIN_ACTION_INSTALL &&
!gs_shell_is_active (priv->shell) &&
((helper->interaction) & GS_SHELL_INTERACTION_NOTIFY) != 0)
gs_app_notify_installed (helper->app);
if (gs_app_is_installed (helper->app) &&
GS_PAGE_GET_CLASS (page)->app_installed != NULL) {
GS_PAGE_GET_CLASS (page)->app_installed (page, helper->app);
}
}
