/***************************************************************************
 * CVSID: $Id$
 *
 * libhal.h : HAL daemon C convenience library headers
 *
 * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
 * Copyright (C) 2007 Codethink Ltd. Author Rob Taylor <rob.taylor@codethink.co.uk>
 *
 * Licensed under the Academic Free License version 2.1
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 **************************************************************************/

#ifndef LIBHAL_H
#define LIBHAL_H

#ifndef DBUS_API_SUBJECT_TO_CHANGE
#define DBUS_API_SUBJECT_TO_CHANGE 
#endif

#include <dbus/dbus.h>

#if defined(__cplusplus)
extern "C" {
#if 0
} /* shut up emacs indenting */
#endif
#endif

#if defined(__GNUC__)
#define LIBHAL_DEPRECATED __attribute__ ((deprecated))  
#else  
#define LIBHAL_DEPRECATED  
#endif 


/**
 * LIBHAL_LIBHAL_FREE_DBUS_ERROR:
 * @_dbus_error_: the DBusError
 *
 * Handy macro for checking whether a DBusError is set and free the error if
 * the error is set.
 */
#define LIBHAL_FREE_DBUS_ERROR(_dbus_error_)					\
	do {									\
		if (dbus_error_is_set(_dbus_error_))				\
			dbus_error_free (_dbus_error_);				\
	} while (0)


/**
 * LIBHAL_CHECK_LIBHALCONTEXT:
 * @_ctx_: the context
 * @_ret_: what to use for return value if context is invalid
 *
 * Handy macro for checking whether a context is valid.
 */
#define LIBHAL_CHECK_LIBHALCONTEXT(_ctx_, _ret_)				\
	do {									\
		if (_ctx_ == NULL) {						\
			fprintf (stderr,					\
				 "%s %d : LibHalContext *ctx is NULL\n", 	\
				 __FILE__, __LINE__);				\
			return _ret_;						\
		}								\
	} while(0)

/** 
 * LibHalPropertyType:
 *
 * Possible types for properties on hal device objects 
 */
typedef enum {
        /** Used to report error condition */
	LIBHAL_PROPERTY_TYPE_INVALID =    DBUS_TYPE_INVALID,

	/** Type for 32-bit signed integer property */
	LIBHAL_PROPERTY_TYPE_INT32   =    DBUS_TYPE_INT32,

	/** Type for 64-bit unsigned integer property */
	LIBHAL_PROPERTY_TYPE_UINT64  =    DBUS_TYPE_UINT64,

	/** Type for double precision floating point property */
	LIBHAL_PROPERTY_TYPE_DOUBLE  =    DBUS_TYPE_DOUBLE,

	/** Type for boolean property */
	LIBHAL_PROPERTY_TYPE_BOOLEAN =    DBUS_TYPE_BOOLEAN,

	/** Type for UTF-8 string property */
	LIBHAL_PROPERTY_TYPE_STRING  =    DBUS_TYPE_STRING,

	/** Type for list of UTF-8 strings property */
	LIBHAL_PROPERTY_TYPE_STRLIST =    ((int) (DBUS_TYPE_STRING<<8)+('l'))
} LibHalPropertyType;


typedef struct LibHalContext_s LibHalContext;
typedef struct LibHalProperty_s LibHalProperty;
typedef struct LibHalPropertySet_s LibHalPropertySet;


/** 
 * LibHalIntegrateDBusIntoMainLoop:
 * @ctx: context for connection to hald
 * @dbus_connection: DBus connection to use in ctx
 *
 * Type for function in application code that integrates a
 * DBusConnection object into its own mainloop.
 */
typedef void (*LibHalIntegrateDBusIntoMainLoop) (LibHalContext *ctx,
						 DBusConnection *dbus_connection);

/** 
 * LibHalDeviceAdded:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 *
 * Type for callback when a device is added.
 */
typedef void (*LibHalDeviceAdded) (LibHalContext *ctx, 
				   const char *udi);

/** 
 * LibHalDeviceRemoved:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 *
 * Type for callback when a device is removed. 
 */
typedef void (*LibHalDeviceRemoved) (LibHalContext *ctx, 
				     const char *udi);

/** 
 * LibHalDeviceNewCapability:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @capability: capability of the device
 *
 * Type for callback when a device gains a new capability.
 *
 */
typedef void (*LibHalDeviceNewCapability) (LibHalContext *ctx, 
					   const char *udi,
					   const char *capability);

/** 
 * LibHalDeviceLostCapability:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @capability: capability of the device
 *
 * Type for callback when a device loses a capability.
 *
 */
typedef void (*LibHalDeviceLostCapability) (LibHalContext *ctx, 
					    const char *udi,
					    const char *capability);

/** 
 * LibHalDevicePropertyModified:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @key: name of the property that has changed
 * @is_removed: whether or not property was removed
 * @is_added: whether or not property was added
 *
 * Type for callback when a property of a device changes. 
 */
typedef void (*LibHalDevicePropertyModified) (LibHalContext *ctx,
					      const char *udi,
					      const char *key,
					      dbus_bool_t is_removed,
					      dbus_bool_t is_added);

/** 
 * LibHalDeviceCondition:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @condition_name: name of the condition, e.g. ProcessorOverheating. Consult the HAL spec for details
 * @condition_detail: detail of condition
 *
 * Type for callback when a non-continuous condition occurs on a device.
 */
typedef void (*LibHalDeviceCondition) (LibHalContext *ctx,
				       const char *udi,
				       const char *condition_name,
				       const char *condition_detail);

/** 
 * LibHalGlobalInterfaceLockAcquired:
 * @ctx: context for connection to hald
 * @interface_name: the name of the interface
 * @lock_owner: what service acquired the lock
 * @num_locks: number of locks on the interface
 *
 * Type for callback when someone acquires a global lock.
 */
typedef void (*LibHalGlobalInterfaceLockAcquired) (LibHalContext *ctx,
                                                   const char *interface_name,
                                                   const char *lock_owner,
                                                   int         num_locks);

/** 
 * LibHalGlobalInterfaceLockReleased:
 * @ctx: context for connection to hald
 * @interface_name: the name of the interface
 * @lock_owner: what service released the lock
 * @num_locks: number of locks on the interface
 *
 * Type for callback when someone releases a global lock.
 */
typedef void (*LibHalGlobalInterfaceLockReleased) (LibHalContext *ctx,
                                                   const char *interface_name,
                                                   const char *lock_owner,
                                                   int         num_locks);

/** 
 * LibHalInterfaceLockAcquired:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @interface_name: the name of the interface
 * @lock_owner: what service acquired the lock
 * @num_locks: number of locks on the interface
 *
 * Type for callback when someone acquires a lock on a device.
 */
typedef void (*LibHalInterfaceLockAcquired) (LibHalContext *ctx,
                                             const char *udi,
                                             const char *interface_name,
                                             const char *lock_owner,
                                             int         num_locks);

/** 
 * LibHalInterfaceLockReleased:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @interface_name: the name of the interface
 * @lock_owner: what service released the lock
 * @num_locks: number of locks on the interface
 *
 * Type for callback when someone acquires a lock on a device.
 */
typedef void (*LibHalInterfaceLockReleased) (LibHalContext *ctx,
                                             const char *udi,
                                             const char *interface_name,
                                             const char *lock_owner,
                                             int         num_locks);

/**
 * LibHalSingletonDeviceAdded:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @properties: the device's properties
 *
 * Type for callback for addon singletons when a device is added
 */
typedef void (*LibHalSingletonDeviceAdded) (LibHalContext *ctx,
					    const char *udi,
					    const LibHalPropertySet *properties);

/**
 * LibHalSingletonDeviceRemoved:
 * @ctx: context for connection to hald
 * @udi: the Unique Device Id
 * @properties: the device's properties
 *
 * Type for callback for addon singletons when a device is added
 */
typedef void (*LibHalSingletonDeviceRemoved) (LibHalContext *ctx,
					    const char *udi,
					    const LibHalPropertySet *properties);



/* Create a new context for a connection with hald */
LibHalContext *libhal_ctx_new                          (void);

/* Enable or disable caching */
dbus_bool_t    libhal_ctx_set_cache                    (LibHalContext *ctx, dbus_bool_t use_cache);

/* Set DBus connection to use to talk to hald. */
dbus_bool_t    libhal_ctx_set_dbus_connection          (LibHalContext *ctx, DBusConnection *conn);

/* Get DBus connection to use to talk to hald. */
DBusConnection *libhal_ctx_get_dbus_connection          (LibHalContext *ctx);

/* Set user data for the context */
dbus_bool_t    libhal_ctx_set_user_data                (LibHalContext *ctx, void *user_data);

/* Get user data for the context */
void*          libhal_ctx_get_user_data                (LibHalContext *ctx);

/* Set the callback for when a device is added */
dbus_bool_t    libhal_ctx_set_device_added             (LibHalContext *ctx, LibHalDeviceAdded callback);

/* Set the callback for when a device is removed */
dbus_bool_t    libhal_ctx_set_device_removed           (LibHalContext *ctx, LibHalDeviceRemoved callback);

/* Set the callback for when a device gains a new capability */
dbus_bool_t    libhal_ctx_set_device_new_capability    (LibHalContext *ctx, LibHalDeviceNewCapability callback);

/* Set the callback for when a device loses a capability */
dbus_bool_t    libhal_ctx_set_device_lost_capability   (LibHalContext *ctx, LibHalDeviceLostCapability callback);

/* Set the callback for when a property is modified on a device */
dbus_bool_t    libhal_ctx_set_device_property_modified (LibHalContext *ctx, LibHalDevicePropertyModified callback);

/* Set the callback for when a device emits a condition */
dbus_bool_t    libhal_ctx_set_device_condition         (LibHalContext *ctx, LibHalDeviceCondition callback);

/* Set the callback for when a global interface lock is acquired  */
dbus_bool_t    libhal_ctx_set_global_interface_lock_acquired (LibHalContext *ctx, LibHalGlobalInterfaceLockAcquired callback);

/* Set the callback for when a global interface lock is released  */
dbus_bool_t    libhal_ctx_set_global_interface_lock_released (LibHalContext *ctx, LibHalGlobalInterfaceLockReleased callback);

/* Set the callback for when an interface lock is acquired  */
dbus_bool_t    libhal_ctx_set_interface_lock_acquired (LibHalContext *ctx, LibHalInterfaceLockAcquired callback);

/* Set the callback for when an interface lock is released  */
dbus_bool_t    libhal_ctx_set_interface_lock_released (LibHalContext *ctx, LibHalInterfaceLockReleased callback);

/* Set the callback for addon singleton device added */
dbus_bool_t    libhal_ctx_set_singleton_device_added (LibHalContext *ctx, LibHalSingletonDeviceAdded callback);

/* Set the callback for addon singleton device removed*/
dbus_bool_t    libhal_ctx_set_singleton_device_removed (LibHalContext *ctx, LibHalSingletonDeviceRemoved callback);

/* Initialize the connection to hald */
dbus_bool_t    libhal_ctx_init                         (LibHalContext *ctx, DBusError *error);

/* Shut down a connection to hald */
dbus_bool_t    libhal_ctx_shutdown                     (LibHalContext *ctx, DBusError *error);

/* Free a LibHalContext resource */
dbus_bool_t    libhal_ctx_free                         (LibHalContext *ctx);

/* Create an already initialized connection to hald */
LibHalContext *libhal_ctx_init_direct                  (DBusError *error);

/* Get all devices in the Global Device List (GDL). */
char        **libhal_get_all_devices (LibHalContext *ctx, int *num_devices, DBusError *error);

/* Determine if a device exists. */
dbus_bool_t   libhal_device_exists   (LibHalContext *ctx, const char *udi,  DBusError *error);

/* Print a device to stdout; useful for debugging. */
dbus_bool_t   libhal_device_print    (LibHalContext *ctx, const char *udi,  DBusError *error);

/* Determine if a property on a device exists. */
dbus_bool_t libhal_device_property_exists (LibHalContext *ctx, 
					   const char *udi,
					   const char *key,
					   DBusError *error);

/* Get the value of a property of type string. */
char *libhal_device_get_property_string (LibHalContext *ctx, 
					 const char *udi,
					 const char *key,
					 DBusError *error);

/* Get the value of a property of type signed integer. */
dbus_int32_t libhal_device_get_property_int (LibHalContext *ctx, 
					     const char *udi,
					     const char *key,
					     DBusError *error);

/* Get the value of a property of type unsigned integer. */
dbus_uint64_t libhal_device_get_property_uint64 (LibHalContext *ctx, 
						 const char *udi,
						 const char *key,
						 DBusError *error);

/* Get the value of a property of type double. */
double libhal_device_get_property_double (LibHalContext *ctx, 
					  const char *udi,
					  const char *key,
					  DBusError *error);

/* Get the value of a property of type bool. */
dbus_bool_t libhal_device_get_property_bool (LibHalContext *ctx, 
					     const char *udi,
					     const char *key,
					     DBusError *error);

/* Get the value of a property of type string list. */
char **libhal_device_get_property_strlist (LibHalContext *ctx, 
					   const char *udi, 
					   const char *key,
					   DBusError *error);

/* Set a property of type string. */
dbus_bool_t libhal_device_set_property_string (LibHalContext *ctx, 
					       const char *udi,
					       const char *key,
					       const char *value,
					       DBusError *error);

/* Set a property of type signed integer. */
dbus_bool_t libhal_device_set_property_int (LibHalContext *ctx, 
					    const char *udi,
					    const char *key,
					    dbus_int32_t value,
					    DBusError *error);

/* Set a property of type unsigned integer. */
dbus_bool_t libhal_device_set_property_uint64 (LibHalContext *ctx, 
					       const char *udi,
					       const char *key,
					       dbus_uint64_t value,
					       DBusError *error);

/* Set a property of type double. */
dbus_bool_t libhal_device_set_property_double (LibHalContext *ctx, 
					       const char *udi,
					       const char *key,
					       double value,
					       DBusError *error);

/* Set a property of type bool. */
dbus_bool_t libhal_device_set_property_bool (LibHalContext *ctx, 
					     const char *udi,
					     const char *key,
					     dbus_bool_t value,
					     DBusError *error);

/* Append to a property of type strlist. */
dbus_bool_t libhal_device_property_strlist_append (LibHalContext *ctx, 
						   const char *udi,
						   const char *key,
						   const char *value,
						   DBusError *error);

/* Prepend to a property of type strlist. */
dbus_bool_t libhal_device_property_strlist_prepend (LibHalContext *ctx, 
						    const char *udi,
						    const char *key,
						    const char *value,
						    DBusError *error);

/* Remove a specified string from a property of type strlist. */
dbus_bool_t libhal_device_property_strlist_remove_index (LibHalContext *ctx, 
							 const char *udi,
							 const char *key,
							 unsigned int idx,
							 DBusError *error);

/* Remove a specified string from a property of type strlist. */
dbus_bool_t libhal_device_property_strlist_remove (LibHalContext *ctx, 
						   const char *udi,
						   const char *key,
						   const char *value,
						   DBusError *error);

/* Remove a property. */
dbus_bool_t libhal_device_remove_property (LibHalContext *ctx, 
					   const char *udi,
					   const char *key,
					   DBusError *error);

/* Query a property type of a device. */
LibHalPropertyType libhal_device_get_property_type (LibHalContext *ctx, 
						    const char *udi,
						    const char *key,
						    DBusError *error);

struct LibHalChangeSet_s;
typedef struct LibHalChangeSet_s LibHalChangeSet;

LibHalChangeSet *libhal_device_new_changeset (const char *udi);

dbus_bool_t libhal_changeset_set_property_string (LibHalChangeSet *changeset,
						  const char *key,
						  const char *value);

dbus_bool_t libhal_changeset_set_property_int (LibHalChangeSet *changeset,
					       const char *key,
					       dbus_int32_t value);

dbus_bool_t libhal_changeset_set_property_uint64 (LibHalChangeSet *changeset,
						  const char *key,
						  dbus_uint64_t value);

dbus_bool_t libhal_changeset_set_property_double (LibHalChangeSet *changeset,
						  const char *key,
						  double value);

dbus_bool_t libhal_changeset_set_property_bool (LibHalChangeSet *changeset,
						const char *key,
						dbus_bool_t value);

dbus_bool_t libhal_changeset_set_property_strlist (LibHalChangeSet *changeset,
						   const char *key,
						   const char **value);

dbus_bool_t libhal_device_commit_changeset (LibHalContext *ctx,
					    LibHalChangeSet *changeset,
					    DBusError *error);

void libhal_device_free_changeset (LibHalChangeSet *changeset);


/* Retrieve all the properties on a device. */
LibHalPropertySet *libhal_device_get_all_properties (LibHalContext *ctx, 
						     const char *udi,
						     DBusError *error);


/* sort all properties according to property name */
void libhal_property_set_sort (LibHalPropertySet *set);

/* Free a property set earlier obtained with libhal_device_get_all_properties(). */
void libhal_free_property_set (LibHalPropertySet *set);

/* Get the number of properties in a property set. */
unsigned int libhal_property_set_get_num_elems (LibHalPropertySet *set);

/* Get type of property. */
LibHalPropertyType libhal_ps_get_type (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type string. */
const char *libhal_ps_get_string  (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type signed integer. */
dbus_int32_t libhal_ps_get_int32 (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type unsigned integer. */
dbus_uint64_t libhal_ps_get_uint64 (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type double. */
double libhal_ps_get_double (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type bool. */
dbus_bool_t libhal_ps_get_bool (const LibHalPropertySet *set, const char *key);

/* Get the value of a property of type string list. */
const char * const *libhal_ps_get_strlist (const LibHalPropertySet *set, const char *key);


/** 
 * LibHalPropertySetIterator: 
 * 
 * Iterator for inspecting all properties. Do not access any members;
 * use the libhal_psi_* family of functions instead.
 */
struct LibHalPropertySetIterator_s {
	LibHalPropertySet *set;    /**< Property set we are iterating over */
	unsigned int idx;          /**< Index into current element */
	LibHalProperty *cur_prop;  /**< Current property being visited */
	void *reservered0;         /**< Reserved for future use */
	void *reservered1;         /**< Reserved for future use */
};


typedef struct LibHalPropertySetIterator_s LibHalPropertySetIterator;

/* Initialize a property set iterator. */
void libhal_psi_init (LibHalPropertySetIterator *iter, LibHalPropertySet *set);

/* Determine whether there are more properties to iterate over */
dbus_bool_t libhal_psi_has_more (LibHalPropertySetIterator *iter);

/* Advance iterator to next property. */
void libhal_psi_next (LibHalPropertySetIterator *iter);

/* Get type of property. */
LibHalPropertyType libhal_psi_get_type (LibHalPropertySetIterator *iter);

/* Get the key of a property. */
char *libhal_psi_get_key (LibHalPropertySetIterator *iter);

/* Get the value of a property of type string. */
char *libhal_psi_get_string (LibHalPropertySetIterator *iter);

/* Get the value of a property of type signed integer. */
dbus_int32_t libhal_psi_get_int (LibHalPropertySetIterator *iter);

/* Get the value of a property of type unsigned integer. */
dbus_uint64_t libhal_psi_get_uint64 (LibHalPropertySetIterator *iter);

/* Get the value of a property of type double. */
double libhal_psi_get_double (LibHalPropertySetIterator *iter);

/* Get the value of a property of type bool. */
dbus_bool_t libhal_psi_get_bool (LibHalPropertySetIterator *iter);

/* Get the value of a property of type string list. */
char **libhal_psi_get_strlist (LibHalPropertySetIterator *iter);

/* Get the length of an array of strings */
unsigned int libhal_string_array_length (char **str_array);

/* Frees a NULL-terminated array of strings. If passed NULL, does nothing. */
void libhal_free_string_array (char **str_array);

/* Frees a nul-terminated string */
void libhal_free_string (char *str);

/* Create a new device object which will be hidden from applications
 * until the CommitToGdl(), ie. libhal_device_commit_to_gdl(), method is called.
 */
char *libhal_new_device (LibHalContext *ctx, DBusError *error);

/* When a hidden device has been built using the NewDevice method, ie.
 * libhal_new_device(), and the org.freedesktop.Hal.Device interface
 * this function will commit it to the global device list. 
 */
dbus_bool_t libhal_device_commit_to_gdl (LibHalContext *ctx,
					 const char *temp_udi,
					 const char *udi,
					 DBusError *error);

/* This method can be invoked when a device is removed. The HAL daemon
 * will shut down the device. Note that the device may still be in the device
 * list if the Persistent property is set to true. 
 */
dbus_bool_t libhal_remove_device (LibHalContext *ctx, 
					const char *udi,
					DBusError *error);

/* Merge properties from one device to another. */
dbus_bool_t libhal_merge_properties (LibHalContext *ctx,
					   const char *target_udi,
					   const char *source_udi,
					   DBusError *error);

/* Check a set of properties for two devices matches. */
dbus_bool_t libhal_device_matches (LibHalContext *ctx,
					 const char *udi1,
					 const char *udi2,
					 const char *property_namespace,
					 DBusError *error);

/* Find a device in the GDL where a single string property matches a
 * given value.
 */
char **libhal_manager_find_device_string_match (LibHalContext *ctx,
						const char *key,
						const char *value,
						int *num_devices,
						DBusError *error);

/* Assign a capability to a device. */
dbus_bool_t libhal_device_add_capability (LibHalContext *ctx,
					  const char *udi,
					  const char *capability,
					  DBusError *error);

/* Check if a device has a capability. The result is undefined if the
 * device doesn't exist.
 */
dbus_bool_t libhal_device_query_capability (LibHalContext *ctx,
					    const char *udi,
					    const char *capability,
					    DBusError *error);

/* Find devices with a given capability. */
char **libhal_find_device_by_capability (LibHalContext *ctx,
					 const char *capability,
					 int *num_devices,
					 DBusError *error);

/* Watch all devices, ie. the device_property_changed callback is
 * invoked when the properties on any device changes.
 */
dbus_bool_t libhal_device_property_watch_all (LibHalContext *ctx,
					      DBusError *error);

/* Add a watch on a device, so the device_property_changed callback is
 * invoked when the properties on the given device changes.
 */
dbus_bool_t libhal_device_add_property_watch (LibHalContext *ctx, 
					      const char *udi,
					      DBusError *error);

/* Remove a watch on a device */
dbus_bool_t libhal_device_remove_property_watch (LibHalContext *ctx, 
						 const char *udi,
						 DBusError *error);

/* Take an advisory lock on the device. */
dbus_bool_t libhal_device_lock (LibHalContext *ctx,
				const char *udi,
				const char *reason_to_lock,
				char **reason_why_locked,
				DBusError *error);

/* Release an advisory lock on the device. */
dbus_bool_t libhal_device_unlock (LibHalContext *ctx,
				  const char *udi,
				  DBusError *error);

dbus_bool_t libhal_device_rescan (LibHalContext *ctx,
				  const char *udi,
				  DBusError *error);

dbus_bool_t libhal_device_reprobe (LibHalContext *ctx,
				   const char *udi,
				   DBusError *error);

/* Emit a condition from a device (for hald helpers only) */
dbus_bool_t libhal_device_emit_condition (LibHalContext *ctx,
					  const char *udi,
					  const char *condition_name,
					  const char *condition_details,
					  DBusError *error);

/* Claim an interface for a device (for hald helpers only) */
dbus_bool_t libhal_device_claim_interface (LibHalContext *ctx,
					   const char *udi,
					   const char *interface_name,
					   const char *introspection_xml,
					   DBusError *error);

/* hald waits for all addons to call this function before announcing the addon (for hald helpers only) */
dbus_bool_t libhal_device_addon_is_ready (LibHalContext *ctx, const char *udi, DBusError *error);

dbus_bool_t libhal_device_singleton_addon_is_ready (LibHalContext *ctx, const char *command_line, DBusError *error);

/* Take a mandatory lock on an interface on a device. */
dbus_bool_t libhal_device_acquire_interface_lock (LibHalContext *ctx,
                                                  const char *udi,
                                                  const char *interface,
                                                  dbus_bool_t exclusive,
                                                  DBusError *error);

/* Release a mandatory lock on an interface on a device. */
dbus_bool_t libhal_device_release_interface_lock (LibHalContext *ctx,
                                                  const char *udi,
                                                  const char *interface,
                                                  DBusError *error);

/* Take a mandatory lock on an interface (the lock affects all devices the caller have access to). */
dbus_bool_t libhal_acquire_global_interface_lock (LibHalContext *ctx,
                                                  const char *interface,
                                                  dbus_bool_t exclusive,
                                                  DBusError *error);

/* Release a mandatory lock on an interface (affects all devices the caller have access to). */
dbus_bool_t libhal_release_global_interface_lock (LibHalContext *ctx,
                                                  const char *interface,
                                                  DBusError *error);

/* Determine if a given caller is locked out of a given interface on a given device */
dbus_bool_t libhal_device_is_caller_locked_out (LibHalContext *ctx,
                                                const char *udi,
                                                const char *interface,
                                                const char *caller,
                                                DBusError *error);

/* Determines whether a determines other processes than the caller holds a lock on the given device.  */
dbus_bool_t libhal_device_is_locked_by_others (LibHalContext *ctx,
                                               const char *udi,
                                               const char *interface,
                                               DBusError *error);

/* Determine if a given caller is privileged (requires HAL to be built with PolicyKit support) */
char* libhal_device_is_caller_privileged (LibHalContext *ctx,
                                          const char *udi,
                                          const char *action,
                                          const char *caller,
                                          DBusError *error);


#if defined(__cplusplus)
}
#endif

#endif /* LIBHAL_H */
