## 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