pk-task-sync

pk-task-sync

Synopsis

PkResults *         pk_task_download_packages_sync      (PkTask *task,
                                                         gchar **package_ids,
                                                         const gchar *directory,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_categories_sync         (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_depends_sync            (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_details_sync            (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_files_sync              (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_packages_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_repo_list_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_requires_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_update_detail_sync      (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_get_updates_sync            (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_install_files_sync          (PkTask *task,
                                                         gchar **files,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_install_packages_sync       (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_refresh_cache_sync          (PkTask *task,
                                                         gboolean force,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_remove_packages_sync        (PkTask *task,
                                                         gchar **package_ids,
                                                         gboolean allow_deps,
                                                         gboolean autoremove,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_repair_system_sync          (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_repo_enable_sync            (PkTask *task,
                                                         const gchar *repo_id,
                                                         gboolean enabled,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_resolve_sync                (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **packages,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_rollback_sync               (PkTask *task,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_search_details_sync         (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_search_files_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_search_groups_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_search_names_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_update_packages_sync        (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_update_system_sync          (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);
PkResults *         pk_task_what_provides_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         PkProvidesEnum provides,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Description

Details

pk_task_download_packages_sync ()

PkResults *         pk_task_download_packages_sync      (PkTask *task,
                                                         gchar **package_ids,
                                                         const gchar *directory,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Downloads packages

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

directory :

the destination directory

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_categories_sync ()

PkResults *         pk_task_get_categories_sync         (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Get the categories available.

task :

a valid PkTask instance

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_depends_sync ()

PkResults *         pk_task_get_depends_sync            (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Get the list of dependent packages.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

recursive :

if we should recurse to packages that depend on other packages

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_details_sync ()

PkResults *         pk_task_get_details_sync            (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Gets details about packages.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_files_sync ()

PkResults *         pk_task_get_files_sync              (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Get the files in a package.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_packages_sync ()

PkResults *         pk_task_get_packages_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Gets the list of packages.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_repo_list_sync ()

PkResults *         pk_task_get_repo_list_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Get the list of available repositories.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_requires_sync ()

PkResults *         pk_task_get_requires_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **package_ids,
                                                         gboolean recursive,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Get the packages this package requires.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

recursive :

if we should return packages that depend on the ones we do

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_update_detail_sync ()

PkResults *         pk_task_get_update_detail_sync      (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Gets details about updates.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_get_updates_sync ()

PkResults *         pk_task_get_updates_sync            (PkTask *task,
                                                         PkBitfield filters,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Gets the update lists.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_install_files_sync ()

PkResults *         pk_task_install_files_sync          (PkTask *task,
                                                         gchar **files,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

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

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

files :

a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.5.3


pk_task_install_packages_sync ()

PkResults *         pk_task_install_packages_sync       (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Install a package of the newest and most correct version.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.5.3


pk_task_refresh_cache_sync ()

PkResults *         pk_task_refresh_cache_sync          (PkTask *task,
                                                         gboolean force,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Refresh the package cache.

task :

a valid PkTask instance

force :

if the metadata should be deleted and re-downloaded even if it is correct

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_remove_packages_sync ()

PkResults *         pk_task_remove_packages_sync        (PkTask *task,
                                                         gchar **package_ids,
                                                         gboolean allow_deps,
                                                         gboolean autoremove,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

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.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

allow_deps :

if other dependent 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. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.5.3


pk_task_repair_system_sync ()

PkResults *         pk_task_repair_system_sync          (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Recover from broken dependencies of installed packages or incomplete installations.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.7.2


pk_task_repo_enable_sync ()

PkResults *         pk_task_repo_enable_sync            (PkTask *task,
                                                         const gchar *repo_id,
                                                         gboolean enabled,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Enable or disable a specific repo.

task :

a valid PkTask instance

repo_id :

The software source ID

enabled :

TRUE or FALSE

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_resolve_sync ()

PkResults *         pk_task_resolve_sync                (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **packages,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Resolves a package name to a package-id.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

packages :

package names to find

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_rollback_sync ()

PkResults *         pk_task_rollback_sync               (PkTask *task,
                                                         const gchar *transaction_id,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Rollback to a previous package state.

task :

a valid PkTask instance

transaction_id :

The transaction ID of the old transaction

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_search_details_sync ()

PkResults *         pk_task_search_details_sync         (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Searches for some package details.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

values :

search values. [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_search_files_sync ()

PkResults *         pk_task_search_files_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Searches for specific files.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

values :

search values. [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_search_groups_sync ()

PkResults *         pk_task_search_groups_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Searches the group lists.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

values :

search values. [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_search_names_sync ()

PkResults *         pk_task_search_names_sync           (PkTask *task,
                                                         PkBitfield filters,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Searches for a package name.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

values :

search values. [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5


pk_task_update_packages_sync ()

PkResults *         pk_task_update_packages_sync        (PkTask *task,
                                                         gchar **package_ids,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Update specific packages to the newest available versions.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

package_ids :

a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.5.3


pk_task_update_system_sync ()

PkResults *         pk_task_update_system_sync          (PkTask *task,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

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

  • pk_task_update_system()

  • pk_task_repo_enable()

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

task :

a valid PkTask instance

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.5.3


pk_task_what_provides_sync ()

PkResults *         pk_task_what_provides_sync          (PkTask *task,
                                                         PkBitfield filters,
                                                         PkProvidesEnum provides,
                                                         gchar **values,
                                                         GCancellable *cancellable,
                                                         PkProgressCallback progress_callback,
                                                         gpointer progress_user_data,
                                                         GError **error);

Find the package that provides some resource.

task :

a valid PkTask instance

filters :

a bitfield of filters that can be used to limit the results

provides :

a PkProvidesEnum type

values :

values to search for. [array zero-terminated=1]

cancellable :

a GCancellable or NULL

progress_callback :

the function to run when the progress changes. [scope call]

progress_user_data :

data to pass to progress_callback

error :

the GError to store any failure, or NULL

Returns :

a PkResults object, or NULL for error. [transfer full]

Since 0.6.5