PK_CLIENT_ERROR

#define PK_CLIENT_ERROR		(pk_client_error_quark ())

PK_CLIENT_TYPE_ERROR

#define PK_CLIENT_TYPE_ERROR (pk_client_error_get_type ())

struct PkClient

struct PkClient;

struct PkClientClass

struct PkClientClass {
	GObjectClass parent_class;

	/* signals */
	void		(* changed)			(PkClient *client);
	/* padding for future expansion */
	void (*_pk_reserved1) (void);
	void (*_pk_reserved2) (void);
	void (*_pk_reserved3) (void);
	void (*_pk_reserved4) (void);
	void (*_pk_reserved5) (void);
};

enum PkClientError

typedef enum {
	PK_CLIENT_ERROR_FAILED,
	PK_CLIENT_ERROR_FAILED_AUTH,
	PK_CLIENT_ERROR_NO_TID,
	PK_CLIENT_ERROR_ALREADY_TID,
	PK_CLIENT_ERROR_ROLE_UNKNOWN,
	PK_CLIENT_ERROR_CANNOT_START_DAEMON,
	PK_CLIENT_ERROR_INVALID_INPUT,
	PK_CLIENT_ERROR_INVALID_FILE,
	PK_CLIENT_ERROR_NOT_SUPPORTED,
	PK_CLIENT_ERROR_DECLINED_SIMULATION,
	/* we define this so we can punt the PkErrorEnums here */
	PK_CLIENT_ERROR_LAST
} PkClientError;

Errors that can be thrown

pk_client_accept_eula_async ()

void                pk_client_accept_eula_async         (PkClient *client,
                                                         const gchar *eula_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

We may want to agree to a EULA dialog if one is presented.

Since 0.5.2

pk_client_adopt_async ()

void                pk_client_adopt_async               (PkClient *client,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Adopt a transaction which allows the caller to monitor the state or cancel it.

Since 0.5.2

pk_client_download_packages_async ()

void                pk_client_download_packages_async   (PkClient *client,
                                                         gchar **package_ids,
                                                         const gchar *directory,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Downloads package files to a specified location.

Since 0.5.2

pk_client_error_quark ()

GQuark              pk_client_error_quark               (void);

Since 0.5.2

pk_client_generic_finish ()

PkResults *         pk_client_generic_finish            (PkClient *client,
                                                         GAsyncResult *res,
                                                         GError **error);

Gets the result from the asynchronous function.

Since 0.5.2

pk_client_get_background ()

gboolean            pk_client_get_background            (PkClient *client);

Gets the background value.

Since 0.6.10

pk_client_get_cache_age ()

guint               pk_client_get_cache_age             (PkClient *client);

Gets the maximum cache age value.

Since 0.6.10

pk_client_get_categories_async ()

void                pk_client_get_categories_async      (PkClient *client,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get a list of all categories supported.

Since 0.5.2

pk_client_get_depends_async ()

void                pk_client_get_depends_async         (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the packages that depend this one, i.e. child->parent.

Since 0.5.2

pk_client_get_details_async ()

void                pk_client_get_details_async         (PkClient *client,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get details of a package, so more information can be obtained for GUI or command line tools.

Since 0.5.2

pk_client_get_distro_upgrades_async ()

void                pk_client_get_distro_upgrades_async (PkClient *client,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

This method should return a list of distribution upgrades that are available. It should not return updates, only major upgrades.

Since 0.5.2

pk_client_get_files_async ()

void                pk_client_get_files_async           (PkClient *client,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the file list (i.e. a list of files installed) for the specified package.

Since 0.5.2

pk_client_get_idle ()

gboolean            pk_client_get_idle                  (PkClient *client);

Gets if the transaction client idle value.

Since 0.6.10

pk_client_get_interactive ()

gboolean            pk_client_get_interactive           (PkClient *client);

Gets the client interactive value.

Since 0.6.10

pk_client_get_locale ()

const gchar *       pk_client_get_locale                (PkClient *client);

Gets the locale used for this transaction.

Since 0.6.10

pk_client_get_old_transactions_async ()

void                pk_client_get_old_transactions_async
                                                        (PkClient *client,
                                                         guint number,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the old transaction list, mainly used for the rollback viewer.

Since 0.5.2

pk_client_get_packages_async ()

void                pk_client_get_packages_async        (PkClient *client,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the list of packages from the backend

Since 0.5.2

pk_client_get_progress_async ()

void                pk_client_get_progress_async        (PkClient *client,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Find the current state of a transaction.

Since 0.5.2

pk_client_get_progress_finish ()

PkProgress *        pk_client_get_progress_finish       (PkClient *client,
                                                         GAsyncResult *res,
                                                         GError **error);

Gets the result from the asynchronous function.

Since 0.5.2

pk_client_get_repo_list_async ()

void                pk_client_get_repo_list_async       (PkClient *client,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the list of repositories installed on the system.

Since 0.5.2

pk_client_get_requires_async ()

void                pk_client_get_requires_async        (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get the packages that require this one, i.e. parent->child.

Since 0.5.2

pk_client_get_update_detail_async ()

void                pk_client_get_update_detail_async   (PkClient *client,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get details about the specific update, for instance any CVE urls and severity information.

Since 0.5.2

pk_client_get_updates_async ()

void                pk_client_get_updates_async         (PkClient *client,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Get a list of all the packages that can be updated for all repositories.

Since 0.5.2

pk_client_install_files_async ()

void                pk_client_install_files_async       (PkClient *client,
                                                         gboolean only_trusted,
                                                         gchar **files,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Install a file locally, and get the deps from the repositories. This is useful for double clicking on a .rpm or .deb file.

Since 0.5.2

pk_client_install_packages_async ()

void                pk_client_install_packages_async    (PkClient *client,
                                                         gboolean only_trusted,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Install a package of the newest and most correct version.

Since 0.5.2

pk_client_install_signature_async ()

void                pk_client_install_signature_async   (PkClient *client,
                                                         PkSigTypeEnum type,
                                                         const gchar *key_id,
                                                         const gchar *package_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Install a software source signature of the newest and most correct version.

Since 0.5.2

pk_client_new ()

PkClient *          pk_client_new                       (void);

PkClient is a nice GObject wrapper for PackageKit and makes writing frontends easy.

Since 0.5.2

pk_client_refresh_cache_async ()

void                pk_client_refresh_cache_async       (PkClient *client,
                                                         gboolean force,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Refresh the cache, i.e. download new metadata from a remote URL so that package lists are up to date. This action may take a few minutes and should be done when the session and system are idle.

Since 0.5.2

pk_client_remove_packages_async ()

void                pk_client_remove_packages_async     (PkClient *client,
                                                         gchar **package_ids,
                                                         gboolean allow_deps,
                                                         gboolean autoremove,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Remove a package (optionally with dependancies) from the system. If allow_deps is set to FALSE, and other packages would have to be removed, then the transaction would fail.

Since 0.5.2

pk_client_repair_system_async ()

void                pk_client_repair_system_async       (PkClient *client,
                                                         gboolean only_trusted,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

This transaction will try to recover from a broken package management system: e.g. the installation of a package with unsatisfied dependencies has been forced by the user using a low level tool (rpm or dpkg) or the system was shutdown during processing an installation.

The backend will decide what is best to do.

Since 0.7.2

pk_client_repo_enable_async ()

void                pk_client_repo_enable_async         (PkClient *client,
                                                         const gchar *repo_id,
                                                         gboolean enabled,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Enable or disable the repository.

Since 0.5.2

pk_client_repo_set_data_async ()

void                pk_client_repo_set_data_async       (PkClient *client,
                                                         const gchar *repo_id,
                                                         const gchar *parameter,
                                                         const gchar *value,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

We may want to set a repository parameter. NOTE: this is free text, and is left to the backend to define a format.

Since 0.5.2

pk_client_resolve_async ()

void                pk_client_resolve_async             (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **packages,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Resolve a package name into a package_id. This can return installed and available packages and allows you find out if a package is installed locally or is available in a repository.

Since 0.5.2

pk_client_rollback_async ()

void                pk_client_rollback_async            (PkClient *client,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

We may want to agree to a EULA dialog if one is presented.

Since 0.5.2

pk_client_search_details_async ()

void                pk_client_search_details_async      (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Search all detailed summary information to try and find a keyword. Think of this as pk_client_search_names(), but trying much harder and taking longer.

Since 0.5.5

pk_client_search_files_async ()

void                pk_client_search_files_async        (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Search for packages that provide a specific file.

Since 0.5.5

pk_client_search_groups_async ()

void                pk_client_search_groups_async       (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Return all packages in a specific group.

Since 0.5.5

pk_client_search_names_async ()

void                pk_client_search_names_async        (PkClient *client,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Search all the locally installed files and remote repositories for a package that matches a specific name.

Since 0.5.5

pk_client_set_background ()

void                pk_client_set_background            (PkClient *client,
                                                         gboolean background);

Sets the background value for the client. A background transaction is usually scheduled at a lower priority and is usually given less network and disk performance.

Since 0.6.10

pk_client_set_cache_age ()

void                pk_client_set_cache_age             (PkClient *client,
                                                         guint cache_age);

Sets the maximum cache age value for the client.

Since 0.6.10

pk_client_set_interactive ()

void                pk_client_set_interactive           (PkClient *client,
                                                         gboolean interactive);

Sets the interactive value for the client. Interactive transactions are usally allowed to ask the user questions.

Since 0.6.10

pk_client_set_locale ()

void                pk_client_set_locale                (PkClient *client,
                                                         const gchar *locale);

Sets the locale to be used for the client. This may affect returned results.

Since 0.6.10

pk_client_simulate_install_files_async ()

void                pk_client_simulate_install_files_async
                                                        (PkClient *client,
                                                         gchar **files,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Simulate an installation of files.

Since 0.5.2

pk_client_simulate_install_packages_async ()

void                pk_client_simulate_install_packages_async
                                                        (PkClient *client,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Simulate an installation of packages.

Since 0.5.2

pk_client_simulate_remove_packages_async ()

void                pk_client_simulate_remove_packages_async
                                                        (PkClient *client,
                                                         gchar **package_ids,
                                                         gboolean autoremove,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Simulate a removal of packages.

Since 0.5.2

pk_client_simulate_repair_system_async ()

void                pk_client_simulate_repair_system_async
                                                        (PkClient *client,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

This transaction simulates a recovery from a broken package management system: e.g. the installation of a package with unsatisfied dependencies has been forced by the user using a low level tool (rpm or dpkg) or the system was shutdown during processing an installation.

The backend will decide what is best to do.

Since 0.7.2

pk_client_simulate_update_packages_async ()

void                pk_client_simulate_update_packages_async
                                                        (PkClient *client,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Simulate an update of packages.

Since 0.5.2

pk_client_test ()

void                pk_client_test                      (gpointer user_data);

pk_client_update_packages_async ()

void                pk_client_update_packages_async     (PkClient *client,
                                                         gboolean only_trusted,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Update specific packages to the newest available versions.

Since 0.5.2

pk_client_update_system_async ()

void                pk_client_update_system_async       (PkClient *client,
                                                         gboolean only_trusted,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Update all the packages on the system with the highest versions found in all repositories. NOTE: you can't choose what repositories to update from, but you can do:

Since 0.5.2

pk_client_upgrade_system_async ()

void                pk_client_upgrade_system_async      (PkClient *client,
                                                         const gchar *distro_id,
                                                         PkUpgradeKindEnum upgrade_kind,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

This transaction will update the distro to the next version, which may involve just downloading the installer and setting up the boot device, or may involve doing an on-line upgrade.

The backend will decide what is best to do.

Since 0.6.11

pk_client_what_provides_async ()

void                pk_client_what_provides_async       (PkClient *client,
                                                         PkBitfield filters,
                                                         PkProvidesEnum provides,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

This should return packages that provide the supplied attributes. This method is useful for finding out what package(s) provide a modalias or GStreamer codec string.

Since 0.5.2

The "background" property

  "background"               gboolean              : Read / Write

Default value: FALSE

Since 0.5.3

The "cache-age" property

  "cache-age"                guint                 : Read / Write

Default value: 0

Since 0.6.10

The "idle" property

  "idle"                     gboolean              : Read

if there are no transactions in progress on this client.

Default value: TRUE

Since 0.5.4

The "interactive" property

  "interactive"              gboolean              : Read / Write

Default value: TRUE

Since 0.5.4

The "locale" property

  "locale"                   gchar*                : Read / Write

Default value: NULL

Since 0.5.3