gs-plugin-eos.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2016-2018 Endless Mobile, Inc
 *
 * Authors:
 *   Joaquim Rocha <jrocha@endlessm.com>
 *
 * Licensed under the GNU General Public License Version 2
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <config.h>

#include <gnome-software.h>
#include <glib/gi18n.h>
#include <gs-plugin.h>

#include "gs-plugin-eos.h"

#define METADATA_SYS_DESKTOP_FILE "EndlessOS::system-desktop-file"

/*
 * SECTION:
 * Plugin to improve GNOME Software integration in the EOS desktop.
 *
 * This plugin runs entirely in the main thread.
 */

struct _GsPluginEos
{
	GsPlugin parent;
};

G_DEFINE_TYPE (GsPluginEos, gs_plugin_eos, GS_TYPE_PLUGIN)

static void
gs_plugin_eos_init (GsPluginEos *self)
{
	/* let the flatpak plugin run first so we deal with the apps
	 * in a more complete/refined state */
	gs_plugin_add_rule (GS_PLUGIN (self), GS_PLUGIN_RULE_RUN_AFTER, "flatpak");
}

static gboolean
app_is_flatpak (GsApp *app)
{
	return gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_FLATPAK;
}

/* Copy of the implementation of gs_flatpak_app_get_ref_name(). */
static const gchar *
app_get_flatpak_ref_name (GsApp *app)
{
	return gs_app_get_metadata_item (app, "flatpak::RefName");
}

static char *
get_desktop_file_id (GsApp *app)
{
	const char *desktop_file_id =
		gs_app_get_metadata_item (app, METADATA_SYS_DESKTOP_FILE);

	if (!desktop_file_id) {
		if (app_is_flatpak (app)) {
			/* ensure we add the .desktop suffix to the app's ref name
			 * since in Flatpak the app ID can have that suffix already
			 * or not, depending on how the appdata has been generated */
			const char *ref_name = app_get_flatpak_ref_name (app);
			return g_strconcat (ref_name, ".desktop", NULL);
		}

		/* just use the app ID if this is not a Flatpak app */
		desktop_file_id = gs_app_get_id (app);
	}

	g_assert (desktop_file_id != NULL);
	return g_strdup (desktop_file_id);
}

void
gs_plugin_adopt_app (GsPlugin *plugin, GsApp *app)
{
	if (app_is_flatpak (app))
		return;

	gs_app_set_management_plugin (app, plugin);
}

static void
refine_core_app (GsApp *app)
{
	if (app_is_flatpak (app) ||
	    (gs_app_get_scope (app) == AS_COMPONENT_SCOPE_UNKNOWN))
		return;

	if (gs_app_get_kind (app) == AS_COMPONENT_KIND_OPERATING_SYSTEM ||
	    gs_app_get_kind (app) == AS_COMPONENT_KIND_WEB_APP)
		return;

	/* Hide non-installed apt packages, as they can’t actually be installed.
	 * The installed ones are pre-installed in the image, and can’t be
	 * removed. We only allow flatpaks to be removed. */
	if (!gs_app_is_installed (app)) {
		gs_app_add_quirk (app, GS_APP_QUIRK_HIDE_EVERYWHERE);
	} else {
		gs_app_add_quirk (app, GS_APP_QUIRK_COMPULSORY);
	}
}

static void
gs_plugin_eos_refine_async (GsPlugin            *plugin,
                            GsAppList           *list,
                            GsPluginRefineFlags  flags,
                            GCancellable        *cancellable,
                            GAsyncReadyCallback  callback,
                            gpointer             user_data)
{
	g_autoptr(GTask) task = NULL;

	task = g_task_new (plugin, cancellable, callback, user_data);
	g_task_set_source_tag (task, gs_plugin_eos_refine_async);

	for (guint i = 0; i < gs_app_list_length (list); i++) {
		GsApp *app = gs_app_list_index (list, i);

		refine_core_app (app);
	}

	g_task_return_boolean (task, TRUE);
}

static gboolean
gs_plugin_eos_refine_finish (GsPlugin      *plugin,
                             GAsyncResult  *result,
                             GError       **error)
{
	return g_task_propagate_boolean (G_TASK (result), error);
}

static gboolean
launch_with_sys_desktop_file (GsApp *app,
                              GError **error)
{
	GdkDisplay *display;
	g_autoptr(GAppLaunchContext) context = NULL;
	g_autofree char *desktop_file_id = get_desktop_file_id (app);
	g_autoptr(GDesktopAppInfo) app_info =
		gs_utils_get_desktop_app_info (desktop_file_id);
	g_autoptr(GError) local_error = NULL;
	gboolean ret;

	display = gdk_display_get_default ();
	context = G_APP_LAUNCH_CONTEXT (gdk_display_get_app_launch_context (display));
	ret = g_app_info_launch (G_APP_INFO (app_info), NULL, context, &local_error);

	if (!ret) {
		g_warning ("Could not launch %s: %s", gs_app_get_unique_id (app),
			   local_error->message);
		g_set_error (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_FAILED,
			     _("Could not launch this application."));
	}

	return ret;
}

gboolean
gs_plugin_launch (GsPlugin *plugin,
		  GsApp *app,
		  GCancellable *cancellable,
		  GError **error)
{
	/* if the app is one of the system ones, we simply launch it through the
	 * plugin's app launcher */
	if (gs_app_has_quirk (app, GS_APP_QUIRK_COMPULSORY) &&
	    !app_is_flatpak (app))
		return gs_plugin_app_launch (plugin, app, error);

	/* for apps that have a special desktop file (e.g. Google Chrome) */
	if (gs_app_get_metadata_item (app, METADATA_SYS_DESKTOP_FILE))
		return launch_with_sys_desktop_file (app, error);

	return TRUE;
}

static void
gs_plugin_eos_class_init (GsPluginEosClass *klass)
{
	GsPluginClass *plugin_class = GS_PLUGIN_CLASS (klass);

	plugin_class->refine_async = gs_plugin_eos_refine_async;
	plugin_class->refine_finish = gs_plugin_eos_refine_finish;
}

GType
gs_plugin_query_type (void)
{
	return GS_TYPE_PLUGIN_EOS;
}