Add toml11 to the CI

.gitea/workflows/test.yaml

@@ -15,7 +15,7 @@ jobs:
         shell: ash {0}
         run: |
           apk -U upgrade
-          apk add --no-cache git bash cmake build-base ninja-is-really-ninja boost-dev
+          apk add --no-cache git bash cmake build-base ninja-is-really-ninja boost-dev toml11
       - uses: actions/checkout@v4
       - name: Build
         run: |

backend/job.cc

@@ -7,6 +7,8 @@
 
 #include <string>
 #include "utils.h"
+#include <pk-backend.h>
+#include <pk-backend-job.h>
 
 namespace slack {
 
@@ -25,34 +27,6 @@ filter_package (PkBitfield filters, bool is_installed)
 	return false;
 }
 
-static std::string
-generate_query(PkBitfield filters)
-{
-	std::string query(
-			"SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
-			"p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
-			"WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = "
-			"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)");
-
-	if (pk_bitfield_contain (filters, PK_FILTER_ENUM_APPLICATION))
-	{
-		query.append(
-				" AND EXISTS (SELECT filelist.full_name "
-				"FROM filelist "
-				"WHERE filelist.full_name = p1.full_name "
-				"AND filelist.filename LIKE 'usr/share/applications/%%.desktop')");
-	}
-	else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_APPLICATION))
-	{
-		query.append(
-				" AND NOT EXISTS (SELECT filelist.full_name "
-				"FROM filelist "
-				"WHERE filelist.full_name = p1.full_name "
-				"AND filelist.filename LIKE 'usr/share/applications/%%.desktop')");
-	}
-	return query;
-}
-
 }
 
 void
@@ -60,16 +34,16 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
 {
 	auto job_data = reinterpret_cast<slack::JobData *> (pk_backend_job_get_user_data (job));
 
-	pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
-	pk_backend_job_set_percentage (job, 0);
-
 	char **vals;
 	PkBitfield filters;
 	g_variant_get (params, "(t^a&s)", &filters, &vals);
 	char *search = g_strjoinv ("%", vals);
 
-	char *query = sqlite3_mprintf (slack::generate_query(filters).c_str(),
-			user_data, search);
+    const char *generate_query = "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
+			"p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
+			"WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = "
+			"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)";
+	char *query = sqlite3_mprintf (generate_query, user_data, search);
 
 	sqlite3_stmt *stmt;
 	if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK))
@@ -77,17 +51,17 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
 		/* Now we're ready to output all packages */
 		while (sqlite3_step (stmt) == SQLITE_ROW)
 		{
-			PkInfoEnum info = slack::is_installed (
+            slack::Info info = slack::is_installed (
 					reinterpret_cast<const char *> (sqlite3_column_text (stmt, 2)));
 
-			if ((info == PK_INFO_ENUM_INSTALLED || info == PK_INFO_ENUM_UPDATING)
+			if ((info == slack::Info::installed || info == slack::Info::updating)
 					&& slack::filter_package (filters, true))
 			{
-				pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED,
+				pk_backend_job_package (job, slack::Info::installed,
 						reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
 				        reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
 			}
-			else if (info == PK_INFO_ENUM_INSTALLING && slack::filter_package (filters, false))
+			else if (info == slack::Info::installing && slack::filter_package (filters, false))
 			{
 				pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
 						reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
@@ -104,6 +78,4 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
 
 	sqlite3_free (query);
 	g_free (search);
-
-	pk_backend_job_set_percentage (job, 100);
 }

backend/pk-backend-slack.cc

@@ -5,7 +5,6 @@
  */
 #include <dirent.h>
 #include <glib/gstdio.h>
-#include <packagekit-glib2/pk-debug.h>
 #include <cstdint>
 #include <stdlib.h>
 #include <stdio.h>
@@ -23,7 +22,7 @@ using namespace slack;
 
 static GSList *repos = nullptr;
 
-void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
+void pk_backend_initialize(GKeyFile *conf)
 {
 	char *path, **groups;
 	int ret;
@@ -130,7 +129,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
 }
 
 void
-pk_backend_destroy(PkBackend *backend)
+pk_backend_destroy()
 {
 	g_debug("backend: destroy");
 
@@ -144,14 +143,11 @@ pk_backend_destroy(PkBackend *backend)
 }
 
 void
-pk_backend_start_job(PkBackend *backend, PkBackendJob *job)
+pk_backend_start_job(PkBackendJob *job)
 {
 	char *db_filename = nullptr;
 	JobData *job_data = g_new0(JobData, 1);
 
-	pk_backend_job_set_allow_cancel(job, true);
-	pk_backend_job_set_allow_cancel(job, false);
-
 	db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr);
 	if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */
 		sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr);
@@ -166,14 +162,13 @@ pk_backend_start_job(PkBackend *backend, PkBackendJob *job)
 	}
 
 	pk_backend_job_set_user_data(job, job_data);
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_RUNNING);
 
 out:
 	g_free(db_filename);
 }
 
 void
-pk_backend_stop_job(PkBackend *backend, PkBackendJob *job)
+pk_backend_stop_job(PkBackendJob *job)
 {
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
@@ -188,19 +183,19 @@ pk_backend_stop_job(PkBackend *backend, PkBackendJob *job)
 }
 
 void
-pk_backend_search_names(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
+pk_backend_search_names(PkBackendJob *job, char **values)
 {
 	pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "name", nullptr);
 }
 
 void
-pk_backend_search_details(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
+pk_backend_search_details(PkBackendJob *job, char **values)
 {
 	pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "desc", nullptr);
 }
 
 void
-pk_backend_search_groups(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
+pk_backend_search_groups(PkBackendJob *job, char **values)
 {
 	pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "cat", nullptr);
 }
@@ -211,10 +206,9 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
 	char **vals, *search;
 	char *query;
 	sqlite3_stmt *stmt;
-	PkInfoEnum ret;
+	Info ret;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
 	pk_backend_job_set_percentage(job, 0);
 
 	g_variant_get(params, "(t^a&s)", nullptr, &vals);
@@ -230,7 +224,7 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
 		while (sqlite3_step(stmt) == SQLITE_ROW)
 		{
 			ret = is_installed((char*) sqlite3_column_text(stmt, 2));
-			if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING))
+			if ((ret == Info::installed) || (ret == Info::updating))
 			{
 				pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
 				                       (char*) sqlite3_column_text(stmt, 0),
@@ -256,15 +250,15 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
 }
 
 void
-pk_backend_search_files(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
+pk_backend_search_files(PkBackendJob *job, char **values)
 {
 	pk_backend_job_thread_create(job, pk_backend_search_files_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_get_details_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
 {
-	char **pkg_ids, *homepage = nullptr;
+	char *homepage = nullptr;
 	char** tokens;
 	gsize i;
 	GString *desc;
@@ -274,10 +268,6 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, void *user_da
 	sqlite3_stmt *stmt;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
-
-	g_variant_get(params, "(^a&s)", &pkg_ids);
-
 	if ((sqlite3_prepare_v2(job_data->db,
 							"SELECT p.desc, p.cat, p.uncompressed FROM pkglist AS p NATURAL JOIN repos AS r "
 							"WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'",
@@ -347,7 +337,7 @@ out:
 }
 
 void
-pk_backend_get_details(PkBackend *backend, PkBackendJob *job, char **package_ids)
+pk_backend_get_details(PkBackendJob *job, char **package_ids)
 {
 	pk_backend_job_thread_create(job, pk_backend_get_details_thread, nullptr, nullptr);
 }
@@ -360,7 +350,6 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
 	PkInfoEnum ret;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
 	pk_backend_job_set_percentage(job, 0);
 
 	g_variant_get(params, "(t^a&s)", nullptr, &vals);
@@ -380,8 +369,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
 
 			while (sqlite3_step(stmt) == SQLITE_ROW)
 			{
-				ret = is_installed((char*) sqlite3_column_text(stmt, 2));
-				if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING))
+                if ((ret == Info::installed) || (ret == Info::updating))
 				{
 					pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
 					                       (char*) sqlite3_column_text(stmt, 0),
@@ -407,7 +395,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
 }
 
 void
-pk_backend_resolve(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **packages)
+pk_backend_resolve(PkBackendJob *job, char **packages)
 {
 	pk_backend_job_thread_create(job, pk_backend_resolve_thread, nullptr, nullptr);
 }
@@ -421,7 +409,6 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, void *u
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
 	g_variant_get(params, "(^a&ss)", &pkg_ids, &dir_path);
-	pk_backend_job_set_status (job, PK_STATUS_ENUM_DOWNLOAD);
 
 	if ((sqlite3_prepare_v2(job_data->db,
 							"SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos "
@@ -468,27 +455,22 @@ out:
 }
 
 void
-pk_backend_download_packages(PkBackend *backend, PkBackendJob *job, char **package_ids, const char *directory)
+pk_backend_download_packages(PkBackendJob *job, char **package_ids, const char *directory)
 {
 	pk_backend_job_thread_create(job, pk_backend_download_packages_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_install_packages_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
 {
 	char *dest_dir_name;
-	char **pkg_ids;
 	unsigned i;
 	gdouble percent_step;
 	GSList *install_list = nullptr, *l;
 	sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr;
-    PkBitfield transaction_flags = 0;
 	PkInfoEnum ret;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);
-
 	if ((sqlite3_prepare_v2(job_data->db,
 							"SELECT summary, cat FROM pkglist NATURAL JOIN repos "
 							"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
@@ -521,18 +503,9 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
 		{
 			/* If it isn't a collection */
 			if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections"))
-			{
-				if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
-				{
-					pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING,
-										   pkg_ids[i],
-										   (char *) sqlite3_column_text(pkglist_stmt, 0));
-				}
-				else
 			{
                 install_list = g_slist_append(install_list, g_strdup(pkg_ids[i]));
 			}
-			}
 			else
 			{
 				sqlite3_bind_text(collection_stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
@@ -541,26 +514,12 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
 				while (sqlite3_step(collection_stmt) == SQLITE_ROW)
 				{
 					ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2));
-					if ((ret == PK_INFO_ENUM_INSTALLING) || (ret == PK_INFO_ENUM_UPDATING))
-					{
-						if ((pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) &&
-							!g_strcmp0((char *) sqlite3_column_text(collection_stmt, 3), "obsolete"))
-						{
-							/* TODO: Don't just skip obsolete packages but remove them */
-						}
-						else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
-						{
-							pk_backend_job_package(job, ret,
-							                       (char *) sqlite3_column_text(collection_stmt, 0),
-							                       (char *) sqlite3_column_text(collection_stmt, 1));
-						}
-						else
+					if ((ret == Info::installing) || (ret == Info::updating))
 					{
                         install_list = g_slist_append(install_list,
                                                       g_strdup((char *) sqlite3_column_text(collection_stmt, 0)));
 					}
 				}
-				}
 				sqlite3_clear_bindings(collection_stmt);
 				sqlite3_reset(collection_stmt);
 			}
@@ -571,13 +530,12 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
 		g_strfreev(tokens);
 	}
 
-	if (install_list && !pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
+	if (install_list)
 	{
 		/* / 2 means total percentage for installing and for downloading */
 		percent_step = 100.0 / g_slist_length(install_list) / 2;
 
 		/* Download the packages */
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
 		dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
 		for (l = install_list, i = 0; l; l = g_slist_next(l), i++)
 		{
@@ -598,7 +556,6 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
 		g_free(dest_dir_name);
 
 		/* Install the packages */
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_INSTALL);
 		for (l = install_list; l; l = g_slist_next(l), i++)
 		{
 			char **tokens;
@@ -623,33 +580,18 @@ out:
 }
 
 void
-pk_backend_install_packages(PkBackend *backend,
-                            PkBackendJob *job,
-                            PkBitfield transaction_flags,
-                            char **package_ids)
+pk_backend_install_packages(PkBackendJob *job, char **package_ids)
 {
 	pk_backend_job_thread_create(job, pk_backend_install_packages_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, void *user_data)
+pk_backend_remove_packages_thread(PkBackendJob* job, char **pkg_ids)
 {
-	char **pkg_ids, *cmd_line;
+	char *cmd_line;
 	unsigned i;
 	gdouble percent_step;
-    bool allow_deps, autoremove;
 	GError *err = nullptr;
-    PkBitfield transaction_flags = 0;
-
-	g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove);
- 
-	if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
-	{
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);
-	}
-	else
-	{
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_REMOVE);
  
     /* Add percent_step percents per removed package */
     percent_step = 100.0 / g_strv_length(pkg_ids);
@@ -678,21 +620,15 @@ pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, void *use
         pk_backend_job_set_percentage(job, 100);
     }
 }
-}
 
 void
-pk_backend_remove_packages(PkBackend *backend,
-                           PkBackendJob *job,
-                           PkBitfield transaction_flags,
-                           char **package_ids,
-                           bool allow_deps,
-                           bool autoremove)
+pk_backend_remove_packages(PkBackendJob *job, char **package_ids)
 {
 	pk_backend_job_thread_create(job, pk_backend_remove_packages_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_get_updates_thread(PkBackendJob *job, void *user_data)
 {
 	char *pkg_id, *full_name, *desc;
 	const char *pkg_metadata_filename;
@@ -703,8 +639,6 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, void *user_da
 	sqlite3_stmt *stmt;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
-
 	if ((sqlite3_prepare_v2(job_data->db,
 							"SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext "
 							"FROM pkglist AS p1 NATURAL JOIN repos AS r "
@@ -796,22 +730,16 @@ out:
 }
 
 void
-pk_backend_get_updates(PkBackend *backend, PkBackendJob *job, PkBitfield filters)
+pk_backend_get_updates(PkBackendJob *job)
 {
 	pk_backend_job_thread_create(job, pk_backend_get_updates_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_update_packages_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
 {
-	char *dest_dir_name, *cmd_line, **pkg_ids;
+	char *dest_dir_name, *cmd_line;
 	unsigned i;
-    PkBitfield transaction_flags = 0;
-
-	g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
-
-	if (!pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
 
     /* Download the packages */
     dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
@@ -835,7 +763,6 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, void *use
     g_free(dest_dir_name);
 
     /* Install the packages */
-		pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE);
     for (i = 0; pkg_ids[i]; i++)
     {
         char **tokens = pk_package_id_split(pkg_ids[i]);
@@ -861,23 +788,18 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, void *use
         g_strfreev(tokens);
 	}
 }
-}
 
 void
-pk_backend_update_packages(PkBackend *backend,
-                           PkBackendJob *job,
-                           PkBitfield transaction_flags,
-                           char **package_ids)
+pk_backend_update_packages(PkBackendJob *job, char **package_ids)
 {
 	pk_backend_job_thread_create(job, pk_backend_update_packages_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_refresh_cache_thread(PkBackendJob *job, bool force, void *user_data)
 {
 	char *tmp_dir_name, *db_err, *path = nullptr;
 	int ret;
-	bool force;
 	GSList *file_list = nullptr;
 	GFile *db_file = nullptr;
 	GFileInfo *file_info = nullptr;
@@ -885,8 +807,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
 	sqlite3_stmt *stmt = nullptr;
 	auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
 
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG);
-
 	/* Create temporary directory */
 	tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err);
 	if (!tmp_dir_name)
@@ -896,8 +816,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
 		return;
 	}
 
-	g_variant_get(params, "(b)", &force);
-
 	/* Force the complete cache refresh if the read configuration file is newer than the metadata cache */
 	if (!force)
 	{
@@ -947,8 +865,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
 	}
 
 	/* Download repository */
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_REPOSITORY);
-
 	for (GSList *l = file_list; l; l = g_slist_next(l))
 	{
 		get_file(&job_data->curl, static_cast<char **> (l->data)[0],
@@ -957,8 +873,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
 	g_slist_free_full(file_list, (GDestroyNotify)g_strfreev);
 
 	/* Refresh cache */
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_REFRESH_CACHE);
-
 	for (GSList *l = repos; l; l = g_slist_next(l))
 	{
 		static_cast<Pkgtools *> (l->data)->generate_cache (job, tmp_dir_name);
@@ -982,20 +896,15 @@ out:
 }
 
 void
-pk_backend_refresh_cache(PkBackend *backend, PkBackendJob *job, bool force)
+pk_backend_refresh_cache(PkBackendJob *job, bool force)
 {
 	pk_backend_job_thread_create(job, pk_backend_refresh_cache_thread, nullptr, nullptr);
 }
 
 static void
-pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, void *user_data)
+pk_backend_get_update_detail_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
 {
 	unsigned i;
-	char **pkg_ids;
-
-	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
-
-	g_variant_get(params, "(^a&s)", &pkg_ids);
 
 	for (i = 0; pkg_ids[i] != nullptr; i++)
 	{
@@ -1016,16 +925,7 @@ pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, void *u
 }
 
 void
-pk_backend_get_update_detail(PkBackend *backend, PkBackendJob *job, char **package_ids)
+pk_backend_get_update_detail(PkBackendJob *job, char **package_ids)
 {
 	pk_backend_job_thread_create(job, pk_backend_get_update_detail_thread, nullptr, nullptr);
 }
-
-PkBitfield
-pk_backend_get_filters (PkBackend *backend)
-{
-	return pk_bitfield_from_enums (
-			PK_FILTER_ENUM_INSTALLED, PK_FILTER_ENUM_NOT_INSTALLED,
-			PK_FILTER_ENUM_APPLICATION, PK_FILTER_ENUM_NOT_APPLICATION,
-			-1);
-}

backend/pkgtools.h

@@ -7,7 +7,6 @@
 
 #include <cstdint>
 #include <glib-object.h>
-#include <pk-backend.h>
 #include "utils.h"
 
 namespace slack {

backend/utils.cc

@@ -131,22 +131,20 @@ split_package_name (const char *pkg_filename)
  * Params:
  * 	pkg_fullname = Package name should be looked for.
  *
- * Returns: PK_INFO_ENUM_INSTALLING if pkg_fullname is already installed,
- *          PK_INFO_ENUM_UPDATING if an elder version of pkg_fullname is
- *          installed, PK_INFO_ENUM_UNKNOWN if pkg_fullname is malformed.
+ * Returns: Package installation information.
  **/
-PkInfoEnum
+Info
 is_installed (const char *pkg_fullname)
 {
 	GFileEnumerator *pkg_metadata_enumerator;
 	GFileInfo *pkg_metadata_file_info;
 	GFile *pkg_metadata_dir;
-	PkInfoEnum ret = PK_INFO_ENUM_INSTALLING;
+	Info ret = Info::installing;
     const char *it;
     std::uint8_t dashes = 0;
 	ptrdiff_t pkg_name;
 
-	g_return_val_if_fail(pkg_fullname != nullptr, PK_INFO_ENUM_UNKNOWN);
+	g_return_val_if_fail(pkg_fullname != nullptr, Info::unknown);
 
     // We want to find the package name without version for the package we're
     // looking for.
@@ -165,7 +163,7 @@ is_installed (const char *pkg_fullname)
     }
 	if (dashes < 2)
 	{
-		return PK_INFO_ENUM_UNKNOWN;
+		return Info::unknown;
 	}
     pkg_name = it - pkg_fullname;
 
@@ -179,7 +177,7 @@ is_installed (const char *pkg_fullname)
 	                                                          nullptr)))
 	{
 		g_object_unref(pkg_metadata_dir);
-		return PK_INFO_ENUM_UNKNOWN;
+		return Info::unknown;
 	}
 
 	while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr)))
@@ -189,7 +187,7 @@ is_installed (const char *pkg_fullname)
 
         if (strcmp(dir, pkg_fullname) == 0)
         {
-            ret = PK_INFO_ENUM_INSTALLED;
+            ret = Info::installed;
         }
 		else
 		{
@@ -206,13 +204,13 @@ is_installed (const char *pkg_fullname)
 			}
 			if (pkg_name == (it - dir) && strncmp(pkg_fullname, dir, pkg_name) == 0)
 			{
-				ret = PK_INFO_ENUM_UPDATING;
+				ret = Info::updating;
 			}
 
 		}
 		g_object_unref(pkg_metadata_file_info);
 
-		if (ret != PK_INFO_ENUM_INSTALLING) /* If installed */
+		if (ret != Info::installing) /* If installed */
 		{
 			break;
 		}

backend/utils.h

@@ -6,8 +6,6 @@
 #pragma once
 
 #include <curl/curl.h>
-#include <pk-backend.h>
-#include <pk-backend-job.h>
 
 namespace slack {
 
@@ -17,11 +15,23 @@ struct JobData
 	CURL *curl;
 };
 
+enum class Info
+{
+    // Error.
+    unknown,
+    // Installed in the same version.
+    installed,
+    // A different version is installed.
+    updating
+    // Available, but not installed.
+    installing,
+};
+
 CURLcode get_file (CURL **curl, char *source_url, char *dest);
 
 char **split_package_name (const char *pkg_filename);
 
-PkInfoEnum is_installed (const char *pkg_fullname);
+Info is_installed (const char *pkg_fullname);
 
 extern "C" {