PkClient

PkClient — For creating new transactions

Synopsis

#define             PK_CLIENT_ERROR
#define             PK_CLIENT_TYPE_ERROR
enum                PkClientError;
                    PkClientPrivate;
                    PkClient;
GQuark              pk_client_error_quark               (void);
PkClient *          pk_client_new                       (void);
void                pk_client_test                      (gpointer user_data);
PkResults *         pk_client_generic_finish            (PkClient *client,
                                                         GAsyncResult *res,
                                                         GError **error);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
void                pk_client_get_distro_upgrades_async (PkClient *client,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);
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);
void                pk_client_get_categories_async      (PkClient *client,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
PkProgress *        pk_client_get_progress_finish       (PkClient *client,
                                                         GAsyncResult *res,
                                                         GError **error);
void                pk_client_get_progress_async        (PkClient *client,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback_ready,
                                                         gpointer user_data);

Object Hierarchy

  GObject
   +----PkClient
         +----PkTask

Properties

  "background"               gboolean              : Read / Write
  "idle"                     gboolean              : Read
  "interactive"              gboolean              : Read / Write
  "locale"                   gchar*                : Read / Write

Description

A GObject to use for accessing PackageKit asynchronously. If you're using PkClient to install, remove, or update packages, be prepared that the eula, gpg and trusted callbacks need to be rescheduled manually, as in http://www.packagekit.org/gtk-doc/introduction-ideas-transactions.html

Details

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 ())


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_ERROR_FAILED

the transaction failed for an unknown reason

PK_CLIENT_ERROR_FAILED_AUTH

PK_CLIENT_ERROR_NO_TID

the transaction id was not pre-allocated (internal error)

PK_CLIENT_ERROR_ALREADY_TID

the transaction id has already been used (internal error)

PK_CLIENT_ERROR_ROLE_UNKNOWN

the role was not set (internal error)

PK_CLIENT_ERROR_CANNOT_START_DAEMON

PK_CLIENT_ERROR_INVALID_INPUT

the package_id is invalid

PK_CLIENT_ERROR_INVALID_FILE

the file is invalid

PK_CLIENT_ERROR_NOT_SUPPORTED

the action is not supported

PK_CLIENT_ERROR_DECLINED_SIMULATION

the simulation was declined by the user

PK_CLIENT_ERROR_LAST


PkClientPrivate

typedef struct _PkClientPrivate PkClientPrivate;

Private PkClient data


PkClient

typedef struct _PkClient PkClient;


pk_client_error_quark ()

GQuark              pk_client_error_quark               (void);

Returns :

Our personal error quark.

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.

Returns :

A new PkClient instance

Since 0.5.2


pk_client_test ()

void                pk_client_test                      (gpointer user_data);

user_data :


pk_client_generic_finish ()

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

Gets the result from the asynchronous function.

client :

a valid PkClient instance

res :

the GAsyncResult

error :

A GError or NULL

Returns :

the PkResults, or NULL. Free with g_object_unref()

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

packages :

an array of package names to resolve, e.g. "gnome-system-tools"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

values :

free text to search for, for instance, "power"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.5


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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

values :

free text to search for, for instance, "power"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

values :

a group enum to search for, for instance, "system-tools"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

values :

file to search for, for instance, "/sbin/service"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.5


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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

directory :

the location where packages are to be downloaded

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_DEVEL or PK_FILTER_ENUM_NONE

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

number :

the number of past transactions to return, or 0 for all

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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: - pk_client_repo_disable() - pk_client_update_system() - pk_client_repo_enable()

client :

a valid PkClient instance

only_trusted :

only trusted packages should be installed

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

recursive :

If we should search recursively for depends

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

recursive :

If we should search recursively for requires

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_GUI | PK_FILTER_ENUM_FREE or PK_FILTER_ENUM_NONE

provides :

a PkProvidesEnum value such as PK_PROVIDES_ENUM_CODEC

values :

a search term such as "sound/mp3"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

allow_deps :

if other dependant packages are allowed to be removed from the computer

autoremove :

if other packages installed at the same time should be tried to remove

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

force :

if we should aggressively drop caches

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

only_trusted :

only trusted packages should be installed

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

type :

the signature type, e.g. PK_SIGTYPE_ENUM_GPG

key_id :

a key ID such as "0df23df"

package_id :

a signature_id structure such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

only_trusted :

only trusted packages should be installed

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

only_trusted :

only trusted packages should be installed

files :

a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

eula_id :

the eula_id we are agreeing to

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

transaction_id :

the transaction_id we want to return to

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

filters :

a PkBitfield such as PK_FILTER_ENUM_DEVEL or PK_FILTER_ENUM_NONE

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.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.

client :

a valid PkClient instance

repo_id :

a repo_id structure such as "livna-devel"

enabled :

if we should enable the repository

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

repo_id :

a repo_id structure such as "livna-devel"

parameter :

the parameter to change

value :

what we should change it to

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2


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.

client :

a valid PkClient instance

files :

a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

autoremove :

if other packages installed at the same time should be tried to remove

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.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.

client :

a valid PkClient instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

transaction_id :

a transaction ID such as "/21_ebcbdaae_data"

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes

progress_user_data :

data to pass to progress_callback

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

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.

client :

a valid PkClient instance

res :

the GAsyncResult

error :

A GError or NULL

Returns :

the PkProgress, or NULL. Free with g_object_unref()

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.

client :

a valid PkClient instance

transaction_id :

a transaction ID such as "/21_ebcbdaae_data"

cancellable :

a GCancellable or NULL

callback_ready :

the function to run on completion

user_data :

the data to pass to callback_ready

Since 0.5.2

Property Details

The "background" property

  "background"               gboolean              : Read / Write

Default value: FALSE

Since 0.5.3


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