PkClient

PkClient — For creating new transactions

Synopsis

        #define             
        PK_CLIENT_ERROR
        #define             
        PK_CLIENT_TYPE_ERROR
        struct              
        PkClient
        ;struct              
        PkClientClass
        ;enum                
        PkClientError
        ;
        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_adopt_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_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
          
        
        );
        
          GQuark
        
        pk_client_error_quark
                       (
        
          
            void
          
        
        );
        
          PkResults
        
         *         
        pk_client_generic_finish
                    (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              GAsyncResult
            
             *res
          
        
        ,                                                         
        
          
            
              GError
            
             **error
          
        
        );
        
          gboolean
        
        pk_client_get_background
                    (
        
          
            
              PkClient
            
             *client
          
        
        );
        
          guint
        
        pk_client_get_cache_age
                     (
        
          
            
              PkClient
            
             *client
          
        
        );
        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_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_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_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
          
        
        );
        
          gboolean
        
        pk_client_get_idle
                          (
        
          
            
              PkClient
            
             *client
          
        
        );
        
          gboolean
        
        pk_client_get_interactive
                   (
        
          
            
              PkClient
            
             *client
          
        
        );const 
        
          gchar
        
         *       
        pk_client_get_locale
                        (
        
          
            
              PkClient
            
             *client
          
        
        );
        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_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_progress_async
                (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            const 
            
              gchar
            
             *transaction_id
          
        
        ,                                                         
        
          
            
              GCancellable
            
             *cancellable
          
        
        ,                                                         
        
          
            
              GAsyncReadyCallback
            
             callback_ready
          
        
        ,                                                         
        
          
            
              gpointer
            
             user_data
          
        
        );
        
          PkProgress
        
         *        
        pk_client_get_progress_finish
               (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              GAsyncResult
            
             *res
          
        
        ,                                                         
        
          
            
              GError
            
             **error
          
        
        );
        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_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_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_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_install_files_async
               (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              PkBitfield
            
             transaction_flags
          
        
        ,                                                         
        
          
            
              gchar
            
             **files
          
        
        ,                                                         
        
          
            
              GCancellable
            
             *cancellable
          
        
        ,                                                         
        
          
            
              PkProgressCallback
            
             progress_callback
          
        
        ,                                                         
        
          
            
              gpointer
            
             progress_user_data
          
        
        ,                                                         
        
          
            
              GAsyncReadyCallback
            
             callback_ready
          
        
        ,                                                         
        
          
            
              gpointer
            
             user_data
          
        
        );
        void
        pk_client_install_packages_async
            (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              PkBitfield
            
             transaction_flags
          
        
        ,                                                         
        
          
            
              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
          
        
        );
        
          PkClient
        
         *          
        pk_client_new
                               (
        
          
            void
          
        
        );
        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_remove_packages_async
             (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              PkBitfield
            
             transaction_flags
          
        
        ,                                                         
        
          
            
              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_repair_system_async
               (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              PkBitfield
            
             transaction_flags
          
        
        ,                                                         
        
          
            
              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_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_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_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_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_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_set_background
                    (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              gboolean
            
             background
          
        
        );
        void
        pk_client_set_cache_age
                     (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              guint
            
             cache_age
          
        
        );
        void
        pk_client_set_interactive
                   (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              gboolean
            
             interactive
          
        
        );
        void
        pk_client_set_locale
                        (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            const 
            
              gchar
            
             *locale
          
        
        );
        void
        pk_client_test
                              (
        
          
            
              gpointer
            
             user_data
          
        
        );
        void
        pk_client_update_packages_async
             (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            
              PkBitfield
            
             transaction_flags
          
        
        ,                                                         
        
          
            
              gchar
            
             **package_ids
          
        
        ,                                                         
        
          
            
              GCancellable
            
             *cancellable
          
        
        ,                                                         
        
          
            
              PkProgressCallback
            
             progress_callback
          
        
        ,                                                         
        
          
            
              gpointer
            
             progress_user_data
          
        
        ,                                                         
        
          
            
              GAsyncReadyCallback
            
             callback_ready
          
        
        ,                                                         
        
          
            
              gpointer
            
             user_data
          
        
        );
        void
        pk_client_upgrade_system_async
              (
        
          
            
              PkClient
            
             *client
          
        
        ,                                                         
        
          
            const 
            
              gchar
            
             *distro_id
          
        
        ,                                                         
        
          
            
              PkUpgradeKindEnum
            
             upgrade_kind
          
        
        ,                                                         
        
          
            
              GCancellable
            
             *cancellable
          
        
        ,                                                         
        
          
            
              PkProgressCallback
            
             progress_callback
          
        
        ,                                                         
        
          
            
              gpointer
            
             progress_user_data
          
        
        ,                                                         
        
          
            
              GAsyncReadyCallback
            
             callback_ready
          
        
        ,                                                         
        
          
            
              gpointer
            
             user_data
          
        
        );
        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
          
        
        );
      

Object Hierarchy

        GObject
           +----PkClient         +----
        PkTask
      
  GEnum   +----PkClientError

Properties

          "
        background
        "               
        
          gboolean
        
                      : Read / Write  "
        cache-age
        "                
        
          guint
        
                         : Read / Write  "
        idle
        "                     
        
          gboolean
        
                      : Read  "
        interactive
        "              
        
          gboolean
        
                      : Read / Write  "
        locale
        "                   
        
          gchar
        
        *                : Read / Write
      

Description

A GObject to use for accessing PackageKit asynchronously. If you'reusing PkClient to install, remove, or update packages, be prepared thatthe eula, gpg and trusted callbacks need to be rescheduled manually, as inhttp://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 ())

struct PkClient

struct PkClient;

struct PkClientClass

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

enum PkClientError

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

Errors that can be thrown

PK_CLIENT_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


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

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

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". [ array zero-terminated=1]

directory  :

the location where packages are to be downloaded

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.2


pk_client_error_quark ()

          
            GQuark
          
                        pk_client_error_quark               (
          
            
              void
            
          
          );
        

Returns  :

Our personal error quark.

Since 0.5.2


pk_client_generic_finish ()

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

Gets the result from the asynchronous function.

client  :

a valid PkClient instance

res  :

the GAsyncResult

error  :

A GError or NULL

Returns  :

the PkResults , or NULL . Free with g_object_unref() . [ transfer full ]

Since 0.5.2


pk_client_get_background ()

          
            gboolean
          
                      pk_client_get_background            (
          
            
              
                PkClient
              
               *client
            
          
          );
        

Gets the background value.

client  :

a valid PkClient instance

Returns  :

The background status.

Since 0.6.10


pk_client_get_cache_age ()

          
            guint
          
                         pk_client_get_cache_age             (
          
            
              
                PkClient
              
               *client
            
          
          );
        

Gets the maximum cache age value.

client  :

a valid PkClient instance

Returns  :

The cache age in seconds

Since 0.6.10


pk_client_get_categories_async ()

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

Get a list of all categories supported.

client  :

a valid PkClient 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

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". [ array zero-terminated=1]

recursive  :

If we should search recursively for depends

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.2


pk_client_get_details_async ()

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

Get details of a package, so more information can be obtained for GUIor 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". [ 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

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

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". [ 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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.2


pk_client_get_idle ()

          
            gboolean
          
                      pk_client_get_idle                  (
          
            
              
                PkClient
              
               *client
            
          
          );
        

Gets if the transaction client idle value.

client  :

a valid PkClient instance

Returns  :

if this client is idle.

Since 0.6.10


pk_client_get_interactive ()

          
            gboolean
          
                      pk_client_get_interactive           (
          
            
              
                PkClient
              
               *client
            
          
          );
        

Gets the client interactive value.

client  :

a valid PkClient instance

Returns  :

if the transaction is due to run interactivly.

Since 0.6.10


pk_client_get_locale ()

          const 
          
            gchar
          
           *       pk_client_get_locale                (
          
            
              
                PkClient
              
               *client
            
          
          );
        

Gets the locale used for this transaction.

client  :

a valid PkClient instance

Returns  :

The locale.

Since 0.6.10


pk_client_get_old_transactions_async ()

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

Get the old transaction list, mainly used for the transaction 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. [ scope call ]

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

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


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() . [ transfer full ]

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

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". [ array zero-terminated=1]

recursive  :

If we should search recursively for requires

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

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 andseverity information.

client  :

a valid PkClient 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

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

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
            
          
          ,                                                         
          
            
              
                PkBitfield
              
               transaction_flags
            
          
          ,                                                         
          
            
              
                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

transaction_flags  :

a transaction type bitfield

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.8.1


pk_client_install_packages_async ()

          void
                          pk_client_install_packages_async    (
          
            
              
                PkClient
              
               *client
            
          
          ,                                                         
          
            
              
                PkBitfield
              
               transaction_flags
            
          
          ,                                                         
          
            
              
                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

transaction_flags  :

a transaction type bitfield

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.8.1


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

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

          
            PkClient
          
           *          pk_client_new                       (
          
            
              void
            
          
          );
        

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

Returns  :

A new PkClient instance

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 thatpackage lists are up to date.This action may take a few minutes and should be done when the session andsystem 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. [ scope call ]

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
            
          
          ,                                                         
          
            
              
                PkBitfield
              
               transaction_flags
            
          
          ,                                                         
          
            
              
                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

transaction_flags  :

a transaction type bitfield

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.8.1


pk_client_repair_system_async ()

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

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

The backend will decide what is best to do.

client  :

a valid PkClient instance

transaction_flags  :

a transaction type bitfield

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.8.1


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

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

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_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 andavailable packages and allows you find out if a package is installed locallyor 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". [ 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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.2


pk_client_search_details_async ()

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

Search all detailed summary information to try and find a keyword.Think of this as pk_client_search_names() , but trying much harder andtaking 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". [ 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

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". [ 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

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". [ 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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.5


pk_client_search_names_async ()

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

Search all the locally installed files and remote repositories for a packagethat 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". [ 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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.5.5


pk_client_set_background ()

          void
                          pk_client_set_background            (
          
            
              
                PkClient
              
               *client
            
          
          ,                                                         
          
            
              
                gboolean
              
               background
            
          
          );
        

Sets the background value for the client. A background transactionis usually scheduled at a lower priority and is usually given lessnetwork and disk performance.

client  :

a valid PkClient instance

background  :

if the transaction is a background transaction

Since 0.6.10


pk_client_set_cache_age ()

          void
                          pk_client_set_cache_age             (
          
            
              
                PkClient
              
               *client
            
          
          ,                                                         
          
            
              
                guint
              
               cache_age
            
          
          );
        

Sets the maximum cache age value for the client.

client  :

a valid PkClient instance

cache_age  :

the cache age to set

Since 0.6.10


pk_client_set_interactive ()

          void
                          pk_client_set_interactive           (
          
            
              
                PkClient
              
               *client
            
          
          ,                                                         
          
            
              
                gboolean
              
               interactive
            
          
          );
        

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

client  :

a valid PkClient instance

interactive  :

the value to set

Since 0.6.10


pk_client_set_locale ()

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

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

client  :

a valid PkClient instance

locale  :

the locale to set, e.g. "en_GB.UTF-8"

Since 0.6.10


pk_client_test ()

          void
                          pk_client_test                      (
          
            
              
                gpointer
              
               user_data
            
          
          );
        

pk_client_update_packages_async ()

          void
                          pk_client_update_packages_async     (
          
            
              
                PkClient
              
               *client
            
          
          ,                                                         
          
            
              
                PkBitfield
              
               transaction_flags
            
          
          ,                                                         
          
            
              
                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

transaction_flags  :

a transaction type bitfield

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.8.1


pk_client_upgrade_system_async ()

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

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

The backend will decide what is best to do.

client  :

a valid PkClient instance

distro_id  :

a distro ID such as "fedora-14"

upgrade_kind  :

a PkUpgradeKindEnum such as PK_UPGRADE_KIND_ENUM_COMPLETE

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

callback_ready  :

the function to run on completion

user_data  :

the data to pass to callback_ready

Since 0.6.11


pk_client_what_provides_async ()

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

This should return packages that provide the supplied attributes.This method is useful for finding out what package(s) provide a modaliasor 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". [ 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

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 "cache-age" property

            "cache-age"                
          
            guint
          
                           : Read / Write
        

Default value: 0

Since 0.6.10


The "idle" property

            "idle"                     
          
            gboolean
          
                        : Read
        

if there are no transactions in progress on this client.

Default value: TRUE

Since 0.5.4


The "interactive" property

            "interactive"              
          
            gboolean
          
                        : Read / Write
        

Default value: TRUE

Since 0.5.4


The "locale" property

            "locale"                   
          
            gchar
          
          *                : Read / Write
        

Default value: NULL

Since 0.5.3