Brian Mattern <rephorm@rephorm.com>
Mathieu Taillefumier <mathieu.taillefumier@free.fr>
+Mike Blumenkrantz (zmike/discomfitor) mike@zentific.com
if BUILD_EOFONO
EOFONO_PC = eofono.pc
endif
-pkgconfig_DATA = edbus.pc $(EHAL_PC) $(ENOTIFY_PC) $(ECONNMAN_PC) $(EBLUEZ_PC) $(EOFONO_PC)
+#if BUILD_EUDEV
+#EUDEV_PC = eudev.pc
+#endif
+if BUILD_EUKIT
+EUKIT_PC = eukit.pc
+endif
+pkgconfig_DATA = edbus.pc $(EHAL_PC) $(ENOTIFY_PC) $(ECONNMAN_PC) $(EBLUEZ_PC) $(EOFONO_PC) $(EUKIT_PC)
+#pkgconfig_DATA = edbus.pc $(EHAL_PC) $(ENOTIFY_PC) $(ECONNMAN_PC) $(EBLUEZ_PC) $(EOFONO_PC) $(EUDEV_PC) $(EUKIT_PC)
EXTRA_DIST = e_dbus.spec
eofono_release_info="-release $release"
edbus_release_info="-release $release"
ehal_release_info="-release $release"
+##eudev_release_info="-release $release"
+eukit_release_info="-release $release"
enotify_release_info="-release $release"
AC_SUBST(version_info)
AC_SUBST(econnman_release_info)
AC_SUBST(eofono_release_info)
AC_SUBST(edbus_release_info)
AC_SUBST(ehal_release_info)
+##AC_SUBST(eudev_release_info)
+AC_SUBST(eukit_release_info)
AC_SUBST(enotify_release_info)
dnl Check enabled modules to build
-AC_ARG_ENABLE([ehal],
- [AC_HELP_STRING([--disable-ehal], [Disable ehal build])],
- [enable_ehal=$enableval],
- [enable_ehal="yes"])
-
-AC_ARG_ENABLE([econnman],
- [AC_HELP_STRING([--enable-econnman], [Enable econnman build])],
- [enable_econnman=$enableval],
- [enable_econnman="yes"])
-
-AC_ARG_ENABLE([ebluez],
- [AC_HELP_STRING([--enable-ebluez], [Enable ebluez build])],
- [enable_ebluez=$enableval],
- [enable_ebluez="yes"])
-
-AC_ARG_ENABLE([eofono],
- [AC_HELP_STRING([--enable-eofono], [Enable eofono build])],
- [enable_eofono=$enableval],
- [enable_eofono="yes"])
-
-AC_ARG_ENABLE([enotify],
- [AC_HELP_STRING([--disable-enotify], [Disable enotify build])],
- [enable_enotify=$enableval],
- [enable_enotify="yes"])
+AC_ARG_ENABLE([ehal],[AC_HELP_STRING([--disable-ehal], [Disable ehal build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ AC_CHECK_PROG([enable_ehal],lshal,yes,no)
+ [enable_ehal=no],
+)
+
+#AC_ARG_ENABLE([eudev],[AC_HELP_STRING([--disable-eudev], [Disable eudev build])])
+#AS_IF(
+# [test "x$enableval" != "xno"],
+# [enable_eudev="yes"],
+# [enable_eudev=no],
+#)
+
+AC_ARG_ENABLE([eukit],[AC_HELP_STRING([--disable-eukit], [Disable eukit build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ AC_CHECK_PROG([enable_eukit],udisks,yes,no)
+ AC_CHECK_PROG([enable_eukit],upower,yes,no),
+ [enable_eukit=no],
+)
+
+AC_ARG_ENABLE([econnman],[AC_HELP_STRING([--enable-econnman], [Enable econnman build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ [enable_econnman="yes"],
+ [enable_econnman=no],
+)
+
+AC_ARG_ENABLE([ebluez],[AC_HELP_STRING([--enable-ebluez], [Enable ebluez build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ [enable_ebluez="yes"],
+ [enable_ebluez=no],
+)
+
+AC_ARG_ENABLE([eofono],[AC_HELP_STRING([--enable-eofono], [Enable eofono build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ [enable_eofono="yes"],
+ [enable_eofono=no],
+)
+
+AC_ARG_ENABLE([enotify],[AC_HELP_STRING([--disable-enotify], [Disable enotify build])])
+AS_IF(
+ [test "x$enableval" != "xno"],
+ [enable_enotify="yes"],
+ [enable_enotify=no],
+)
# pkg-config
PKG_PROG_PKG_CONFIG
# Check whether pkg-config supports Requires.private
-if $PKG_CONFIG --atleast-pkgconfig-version 0.22; then
- pkgconfig_requires_private="Requires.private"
-else
- pkgconfig_requires_private="Requires"
-fi
+AS_IF(
+ [$PKG_CONFIG --atleast-pkgconfig-version 0.22],
+ [pkgconfig_requires_private="Requires.private"],
+ [pkgconfig_requires_private="Requires"]
+)
AC_SUBST(pkgconfig_requires_private)
PKG_CHECK_MODULES([EINA], [eina-0])
DBUS_VERSION_MAJOR=`echo $dbus_version | awk -F. '{print $1}'`
DBUS_VERSION_MINOR=`echo $dbus_version | awk -F. '{print $2}'`
DBUS_VERSION_MICRO=`echo $dbus_version | awk -F. '{print $3}'`
-if test "z$DBUS_VERSION_MAJOR" = "z"; then
- DBUS_VERSION_MAJOR="0"
-fi
-if test "z$DBUS_VERSION_MINOR" = "z"; then
- DBUS_VERSION_MINOR="0"
-fi
-if test "z$DBUS_VERSION_MICRO" = "z"; then
- DBUS_VERSION_MICRO="0"
-fi
+AS_IF(
+ [test "z$DBUS_VERSION_MAJOR" = "z"],
+ [DBUS_VERSION_MAJOR="0"]
+)
+AS_IF(
+ [test "z$DBUS_VERSION_MINOR" = "z"],
+ [DBUS_VERSION_MINOR="0"]
+)
+AS_IF(
+ [test "z$DBUS_VERSION_MICRO" = "z"],
+ [DBUS_VERSION_MICRO="0"]
+)
DBUS_VERSION_CFLAGS="$DBUS_VERSION_CFLAGS -DDBUS_VERSION_MAJOR=$DBUS_VERSION_MAJOR"
DBUS_VERSION_CFLAGS="$DBUS_VERSION_CFLAGS -DDBUS_VERSION_MINOR=$DBUS_VERSION_MINOR"
DBUS_VERSION_CFLAGS="$DBUS_VERSION_CFLAGS -DDBUS_VERSION_MICRO=$DBUS_VERSION_MICRO"
AC_FUNC_ALLOCA
dnl evas
-if test "x${enable_enotify}" = "xyes" ; then
- PKG_CHECK_MODULES(EVAS, [evas >= 0.9.9], [], [enable_enotify="no"])
-fi
+AS_IF(
+ [test "x${enable_enotify}" = "xyes"],
+ [PKG_CHECK_MODULES(EVAS, [evas >= 0.9.9], [], [enable_enotify="no"])]
+)
+
+#AS_IF(
+# [test "x${enable_eudev}" = "xyes"],
+# [PKG_CHECK_MODULES(EUDEV, udev, [], [enable_eudev="no"])]
+#)
AM_CONDITIONAL([BUILD_EHAL], [test "x${enable_ehal}" = "xyes"])
+#AM_CONDITIONAL([BUILD_EUDEV], [test "x${enable_eudev}" = "xyes"])
+AM_CONDITIONAL([BUILD_EUKIT], [test "x${enable_eukit}" = "xyes"])
AM_CONDITIONAL([BUILD_ENOTIFY], [test "x${enable_enotify}" = "xyes"])
AM_CONDITIONAL([BUILD_ECONNMAN], [test "x${enable_econnman}" = "xyes"])
AM_CONDITIONAL([BUILD_EBLUEZ], [test "x${enable_ebluez}" = "xyes"])
EFL_EDBUS_BUILD=""
lt_enable_auto_import=""
-case "$host_os" in
- mingw* | cegcc*)
- EFL_EDBUS_BUILD="-DEFL_EDBUS_BUILD"
- lt_enable_auto_import="-Wl,--enable-auto-import"
- ;;
-esac
+AS_CASE(
+ ["$host_os"],
+ [mingw* | cegcc*],
+ [
+ EFL_EDBUS_BUILD="-DEFL_EDBUS_BUILD"
+ lt_enable_auto_import="-Wl,--enable-auto-import"
+ ]
+)
AC_SUBST(EFL_EDBUS_BUILD)
AC_SUBST(lt_enable_auto_import)
src/lib/Makefile
src/lib/dbus/Makefile
src/lib/hal/Makefile
+src/lib/ukit/Makefile
src/lib/notification/Makefile
src/lib/connman/Makefile
src/lib/bluez/Makefile
src/bin/Makefile
edbus.pc
ehal.pc
+eukit.pc
enotify.pc
econnman.pc
ebluez.pc
echo " Modules:"
echo
echo " EHal...............: $enable_ehal"
+echo " EUdev..............: $enable_eudev"
+echo " EUkit..............: $enable_eukit"
echo " EConnman...........: $enable_econnman"
echo " EBluez.............: $enable_ebluez"
echo " EOfono.............: $enable_eofono"
-I$(top_srcdir)/src/lib/connman \
-I$(top_srcdir)/src/lib/bluez \
-I$(top_srcdir)/src/lib/ofono \
+-I$(top_srcdir)/src/lib/ukit \
@EDBUS_CFLAGS@ \
@EINA_CFLAGS@
if BUILD_EOFONO
EOFONO_PROG = e_dbus_ofono_test
endif
+if BUILD_EUKIT
+EUKIT_PROG = e_dbus_ukit_test
+endif
bin_PROGRAMS = \
$(EDBUS_PROG) \
$(ENOTIFY_PROG) \
$(ECONNMAN_PROG) \
$(EBLUEZ_PROG) \
-$(EOFONO_PROG)
+$(EOFONO_PROG) \
+$(EUKIT_PROG)
noinst_PROGRAMS = \
$(ECONNMAN_PROG_NOINST)
e_dbus_ofono_test_CPPFLAGS = $(EDBUS_CPPFLAGS)
e_dbus_ofono_test_LDADD = $(top_builddir)/src/lib/ofono/libeofono.la
endif
+
+if BUILD_EUKIT
+e_dbus_ukit_test_SOURCES = e_dbus_ukit_test.c
+e_dbus_ukit_test_CPPFLAGS = $(EDBUS_CPPFLAGS)
+e_dbus_ukit_test_LDADD = $(top_builddir)/src/lib/ukit/libeukit.la
+endif
MAINTAINERCLEANFILES = Makefile.in
-SUBDIRS=dbus hal notification connman bluez ofono
+SUBDIRS=dbus hal notification connman bluez ofono ukit
struct E_Hal_Bool_Return
{
- char boolean;
+ Eina_Bool boolean;
};
struct E_Hal_UDI_Return
{
const char *s;
int i;
- dbus_bool_t b;
+ Eina_Bool b;
double d;
- dbus_uint64_t u64;
+ uint64_t u64;
Eina_List *strlist;
} val;
};
EAPI DBusPendingCall *e_hal_manager_find_device_by_capability(E_DBus_Connection *conn, const char *capability, E_DBus_Callback_Func cb_func, void *data);
/* utility functions */
- EAPI void e_hal_property_free(E_Hal_Property *prop);
- EAPI char *e_hal_property_string_get(E_Hal_Properties *properties, const char *key, int *err);
- EAPI char e_hal_property_bool_get(E_Hal_Properties *properties, const char *key, int *err);
- EAPI int e_hal_property_int_get(E_Hal_Properties *properties, const char *key, int *err);
- EAPI dbus_uint64_t e_hal_property_uint64_get(E_Hal_Properties *properties, const char *key, int *err);
- EAPI double e_hal_property_double_get(E_Hal_Properties *properties, const char *key, int *err);
- EAPI Eina_List *e_hal_property_strlist_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI void e_hal_property_free(E_Hal_Property *prop);
+ EAPI const char *e_hal_property_string_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI Eina_Bool e_hal_property_bool_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI int e_hal_property_int_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI uint64_t e_hal_property_uint64_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI double e_hal_property_double_get(E_Hal_Properties *properties, const char *key, int *err);
+ EAPI const Eina_List *e_hal_property_strlist_get(E_Hal_Properties *properties, const char *key, int *err);
/* (un)mount */
EAPI DBusPendingCall *e_hal_device_volume_mount(E_DBus_Connection *conn, const char *udi, const char *mount_point, const char *fstype, Eina_List *options, E_DBus_Callback_Func cb_func, void *data);
E_Hal_Device_Get_Property_Return *ret = NULL;
DBusMessageIter iter;
int type;
+ char *tmp;
ret = calloc(1, sizeof(E_Hal_Device_Get_Property_Return));
if (!ret)
type = dbus_message_iter_get_arg_type(&iter);
switch(type)
{
- case 's':
- dbus_message_iter_get_basic(&iter, &(ret->val.s));
+ case DBUS_TYPE_STRING:
+ dbus_message_iter_get_basic(&iter, &tmp);
+ ret->val.s = (char*)eina_stringshare_add(tmp);
break;
- case 'i':
+ case DBUS_TYPE_INT32:
dbus_message_iter_get_basic(&iter, &(ret->val.i));
break;
- case 'b':
+ case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(&iter, &(ret->val.b));
break;
- case 'd':
+ case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic(&iter, &(ret->val.d));
break;
}
E_Hal_Device_Get_Property_Return *ret = data;
if (!ret) return;
+ if (ret->type == E_HAL_PROPERTY_TYPE_STRLIST)
+ {
+ const char *s;
+ EINA_LIST_FREE(ret->val.strlist, s)
+ eina_stringshare_del(s);
+ }
+ else if (ret->type == E_HAL_PROPERTY_TYPE_STRING)
+ eina_stringshare_del(ret->val.s);
free(ret);
}
{
E_Hal_Device_Get_All_Properties_Return *ret = NULL;
DBusMessageIter iter, a_iter, s_iter, v_iter;
+ char *tmp;
+ /* a{sv} = array of string+variant */
if (!dbus_message_has_signature(msg, "a{sv}"))
{
dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
switch(dbus_message_iter_get_arg_type(&v_iter))
{
- case 's':
+ case DBUS_TYPE_STRING:
prop->type = E_HAL_PROPERTY_TYPE_STRING;
- dbus_message_iter_get_basic(&v_iter, &(prop->val.s));
+ dbus_message_iter_get_basic(&v_iter, &tmp);
+ prop->val.s = (char*)eina_stringshare_add(tmp);
break;
- case 'i':
+ case DBUS_TYPE_INT32:
prop->type = E_HAL_PROPERTY_TYPE_INT;
dbus_message_iter_get_basic(&v_iter, &(prop->val.i));
break;
- case 't':
+ case DBUS_TYPE_UINT64:
prop->type = E_HAL_PROPERTY_TYPE_UINT64;
dbus_message_iter_get_basic(&v_iter, &(prop->val.u64));
break;
- case 'b':
+ case DBUS_TYPE_BOOLEAN:
prop->type = E_HAL_PROPERTY_TYPE_BOOL;
dbus_message_iter_get_basic(&v_iter, &(prop->val.b));
break;
- case 'd':
+ case DBUS_TYPE_DOUBLE:
prop->type = E_HAL_PROPERTY_TYPE_DOUBLE;
dbus_message_iter_get_basic(&v_iter, &(prop->val.d));
break;
- case 'a':
+ case DBUS_TYPE_ARRAY:
prop->type = E_HAL_PROPERTY_TYPE_STRLIST;
{
DBusMessageIter list_iter;
{
char *str;
dbus_message_iter_get_basic(&list_iter, &str);
- prop->val.strlist = eina_list_append(prop->val.strlist, str);
+ tmp = (char*)eina_stringshare_add(str);
+ prop->val.strlist = eina_list_append(prop->val.strlist, tmp);
dbus_message_iter_next(&list_iter);
}
}
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &mount_point);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fstype);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &subiter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
if (options)
{
msg = e_hal_device_volume_call_new(udi, "Unmount");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &subiter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
if (options)
{
const char *opt;
msg = e_hal_device_volume_call_new(udi, "Eject");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &subiter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
if (options)
{
const char *opt;
free_string_list(void *data)
{
E_Hal_String_List_Return *ret = data;
+ const char *x;
if (!ret) return;
- eina_list_free(ret->strings);
+ EINA_LIST_FREE(ret->strings, x)
+ eina_stringshare_del(x);
free(ret);
}
* @param key the key of the property to retrieve
* @param err a pointer to an int, which if supplied, will be set to 0 on success and 1 on an error
*/
-EAPI char *
+EAPI const char *
e_hal_property_string_get(E_Hal_Properties *properties, const char *key, int *err)
{
E_Hal_Property *prop;
if (err) *err = 0;
if (!properties->properties) return NULL;
prop = eina_hash_find(properties->properties, key);
- if (prop) return strdup(prop->val.s);
+ if (prop) return prop->val.s;
if (err) *err = 1;
return NULL;
}
-EAPI char
+EAPI Eina_Bool
e_hal_property_bool_get(E_Hal_Properties *properties, const char *key, int *err)
{
E_Hal_Property *prop;
return 0;
}
-EAPI dbus_uint64_t
+EAPI uint64_t
e_hal_property_uint64_get(E_Hal_Properties *properties, const char *key, int *err)
{
E_Hal_Property *prop;
return 0;
}
-EAPI Eina_List *
+EAPI const Eina_List *
e_hal_property_strlist_get(E_Hal_Properties *properties, const char *key, int *err)
{
E_Hal_Property *prop;
#include "E_Hal.h"
void e_hal_property_free(E_Hal_Property *prop);
-char *e_hal_property_string_get(E_Hal_Properties *properties, const char *key, int *err);
+const char *e_hal_property_string_get(E_Hal_Properties *properties, const char *key, int *err);
char e_hal_property_bool_get(E_Hal_Properties *properties, const char *key, int *err);
int e_hal_property_int_get(E_Hal_Properties *properties, const char *key, int *err);
-dbus_uint64_t e_hal_property_uint64_get(E_Hal_Properties *properties, const char *key, int *err);
+uint64_t e_hal_property_uint64_get(E_Hal_Properties *properties, const char *key, int *err);
double e_hal_property_double_get(E_Hal_Properties *properties, const char *key, int *err);
-Eina_List *e_hal_property_strlist_get(E_Hal_Properties *properties, const char *key, int *err);
+const Eina_List *e_hal_property_strlist_get(E_Hal_Properties *properties, const char *key, int *err);
#endif
--- /dev/null
+#ifndef E_UKIT_H
+#define E_UKIT_H
+#include <E_DBus.h>
+#include <eina_stringshare.h>
+
+#ifdef EAPI
+#undef EAPI
+#endif
+#ifdef _MSC_VER
+# ifdef BUILDING_DLL
+# define EAPI __declspec(dllexport)
+# else
+# define EAPI __declspec(dllimport)
+# endif
+#else
+# ifdef __GNUC__
+# if __GNUC__ >= 4
+# define EAPI __attribute__ ((visibility("default")))
+# else
+# define EAPI
+# endif
+# else
+# define EAPI
+# endif
+#endif
+
+#define E_UKIT_PROP_INTERFACE "org.freedesktop.DBus.Properties"
+
+#define E_UDISKS_BUS "org.freedesktop.UDisks"
+#define E_UDISKS_PATH "/org/freedesktop/UDisks"
+#define E_UDISKS_INTERFACE "org.freedesktop.UDisks.Device"
+
+#define E_UPOWER_BUS "org.freedesktop.UPower"
+#define E_UPOWER_PATH "/org/freedesktop/UPower"
+#define E_UPOWER_INTERFACE "org.freedesktop.UPower.Device"
+
+/* message return types */
+
+typedef struct E_Ukit_Property E_Ukit_Property;
+typedef struct E_Ukit_Properties E_Ukit_Properties;
+
+struct E_Ukit_String_List_Return
+{
+ Eina_List *strings; /* list of const char * */
+};
+
+struct E_Ukit_Bool_Return
+{
+ Eina_Bool boolean;
+};
+
+struct E_Ukit_UDI_Return
+{
+ const char *udi;
+};
+
+struct E_Ukit_Capability
+{
+ const char *udi;
+ const char *capability;
+};
+
+typedef enum
+{
+ E_UKIT_PROPERTY_TYPE_STRING,
+ E_UKIT_PROPERTY_TYPE_INT,
+ E_UKIT_PROPERTY_TYPE_UINT32,
+ E_UKIT_PROPERTY_TYPE_UINT64,
+ E_UKIT_PROPERTY_TYPE_INT64,
+ E_UKIT_PROPERTY_TYPE_BOOL,
+ E_UKIT_PROPERTY_TYPE_DOUBLE,
+ E_UKIT_PROPERTY_TYPE_STRLIST
+} E_Ukit_Property_Type;
+
+struct E_Ukit_Property
+{
+ E_Ukit_Property_Type type;
+ union
+ {
+ const char *s;
+ int i;
+ Eina_Bool b;
+ double d;
+ uint32_t u;
+ uint64_t t;
+ int64_t x;
+ Eina_List *strlist;
+ } val;
+};
+
+struct E_Ukit_Properties
+{
+ Eina_Hash *properties;
+};
+
+typedef enum
+{
+ E_UPOWER_BATTERY_UNKNOWN,
+ E_UPOWER_BATTERY_LION,
+ E_UPOWER_BATTERY_LPOLYMER,
+ E_UPOWER_BATTERY_LIRONPHOS,
+ E_UPOWER_BATTERY_LEAD,
+ E_UPOWER_BATTERY_NICAD,
+ E_UPOWER_BATTERY_METALHYDRYDE
+} E_UPower_Battery_Type;
+
+typedef enum
+{
+ E_UPOWER_STATE_UNKNOWN,
+ E_UPOWER_STATE_CHARGING,
+ E_UPOWER_STATE_DISCHARGING,
+ E_UPOWER_STATE_EMPTY,
+ E_UPOWER_STATE_FULL,
+ E_UPOWER_STATE_PENDINGCHARGE,
+ E_UPOWER_STATE_PENDINGDISCHARGE
+} E_Upower_State;
+
+typedef enum
+{
+ E_UPOWER_SOURCE_UNKNOWN,
+ E_UPOWER_SOURCE_AC,
+ E_UPOWER_SOURCE_BATTERY,
+ E_UPOWER_SOURCE_UPS,
+ E_UPOWER_SOURCE_MONITOR,
+ E_UPOWER_SOURCE_MOUSE,
+ E_UPOWER_SOURCE_KEYBOARD,
+ E_UPOWER_SOURCE_PDA,
+ E_UPOWER_SOURCE_PHONE
+} E_Upower_Source;
+
+
+typedef struct E_Ukit_Properties E_Ukit_Get_All_Properties_Return;
+typedef struct E_Ukit_Property E_Ukit_Get_Property_Return;
+typedef struct E_Ukit_String_List_Return E_Ukit_String_List_Return;
+typedef struct E_Ukit_String_List_Return E_Ukit_Get_All_Devices_Return;
+
+typedef struct E_Ukit_UDI_Return E_Ukit_Device_Added;
+typedef struct E_Ukit_UDI_Return E_Ukit_Device_Removed;
+typedef struct E_Ukit_Capability E_Ukit_New_Capability;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ EAPI int e_ukit_init(void);
+ EAPI int e_ukit_shutdown(void);
+
+ EAPI DBusPendingCall *e_udisks_get_property(E_DBus_Connection *conn, const char *udi, const char *property, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_udisks_get_all_properties(E_DBus_Connection *conn, const char *udi, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_udisks_get_all_devices(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data);
+
+ EAPI DBusPendingCall *e_upower_get_property(E_DBus_Connection *conn, const char *udi, const char *property, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_upower_get_all_properties(E_DBus_Connection *conn, const char *udi, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_upower_get_all_devices(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data);
+
+/* utility functions */
+ EAPI void e_ukit_property_free(E_Ukit_Property *prop);
+ EAPI const char *e_ukit_property_string_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI Eina_Bool e_ukit_property_bool_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI int e_ukit_property_int_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI uint32_t e_ukit_property_uint32_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI uint64_t e_ukit_property_uint64_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI int64_t e_ukit_property_int64_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI double e_ukit_property_double_get(E_Ukit_Properties *properties, const char *key, int *err);
+ EAPI const Eina_List *e_ukit_property_strlist_get(E_Ukit_Properties *properties, const char *key, int *err);
+
+/* (un)mount */
+ EAPI DBusPendingCall *e_udisks_volume_mount(E_DBus_Connection *conn, const char *udi, const char *fstype, Eina_List *options, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_udisks_volume_unmount(E_DBus_Connection *conn, const char *udi, Eina_List *options, E_DBus_Callback_Func cb_func, void *data);
+ EAPI DBusPendingCall *e_udisks_volume_eject(E_DBus_Connection *conn, const char *udi, Eina_List *options, E_DBus_Callback_Func cb_func, void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I $(top_srcdir)/src/lib/dbus \
+@EDBUS_CFLAGS@ @EINA_CFLAGS@
+
+if BUILD_EUKIT
+
+lib_LTLIBRARIES = libeukit.la
+include_HEADERS = E_Ukit.h
+
+noinst_HEADERS = e_ukit_private.h e_ukit_privfunc.h
+
+libeukit_la_SOURCES = \
+E_Ukit.h \
+e_udisks.c \
+e_upower.c \
+e_ukit_util.c \
+e_ukit_main.c
+
+libeukit_la_LIBADD = \
+@EDBUS_LIBS@ \
+$(top_builddir)/src/lib/dbus/libedbus.la \
+@EINA_LIBS@
+libeukit_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @eukit_release_info@
+
+endif
--- /dev/null
+#include <E_Ukit.h>
+#include "e_ukit_private.h"
+
+#define E_UKIT_BUS E_UDISKS_BUS
+#define E_UKIT_PATH E_UDISKS_PATH
+#define E_UKIT_INTERFACE E_UDISKS_INTERFACE
+
+const char *e_udisks_iface="org.freedesktop.UDisks.Device";
+
+#if 0
+static void cb_device_get_property(void *data, DBusMessage *msg, DBusError *err);
+static void cb_device_get_all_properties(void *data, DBusMessage *msg, DBusError *err);
+static void cb_device_query_capability(void *data, DBusMessage *msg, DBusError *err);
+#endif
+
+/* Properties.Get */
+EAPI DBusPendingCall *
+e_udisks_get_property(E_DBus_Connection *conn, const char *udi, const char *property, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_property_call_new(udi, "Get");
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &e_udisks_iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID);
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_property, cb_func, free_property, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/* Properties.GetAll */
+EAPI DBusPendingCall *
+e_udisks_get_all_properties(E_DBus_Connection *conn, const char *udi, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_property_call_new(udi, "GetAll");
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &e_udisks_iface, DBUS_TYPE_INVALID);
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_device_get_all_properties, cb_func, free_device_get_all_properties, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+
+
+/* void FilesystemMount(string fstype, array{string}options) */
+
+/**
+ * @brief Mount a Filesystem
+ *
+ * @param conn the E_DBus_Connection
+ * @param udi the udi of the device object
+ * @param fstype the fstype of the device (e.g. volume.fstype property)
+ * @param options a list of additional options (not sure... fstype dependant?)
+ * @param cb_func an optional callback to call when the mount is done
+ * @param data custom data pointer for the callback function
+ *
+ * @return mount point of fs or error
+ */
+EAPI DBusPendingCall *
+e_udisks_volume_mount(E_DBus_Connection *conn, const char *udi, const char *fstype, Eina_List *options, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusMessageIter iter, subiter;
+ Eina_List *l;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_device_call_new(udi, "FilesystemMount");
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fstype);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
+
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter) ;
+
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_property, cb_func, free_property, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/* void Unmount(array{string} options) */
+
+/**
+ * @brief Unmount a Volume
+ *
+ * @param conn the E_DBus_Connection
+ * @param udi the udi of the device object
+ * @param options a list of additional options (currently only 'force' is supported)
+ * @param cb_func an optional callback to call when the unmount is done
+ * @param data custom data pointer for the callback function
+ */
+EAPI DBusPendingCall *
+e_udisks_volume_unmount(E_DBus_Connection *conn, const char *udi, Eina_List *options, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusMessageIter iter, subiter;
+ Eina_List *l;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_device_call_new(udi, "FilesystemUnmount");
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter) ;
+
+ ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/**
+ * @brief Eject a Volume
+ *
+ * @param conn the E_DBus_Connection
+ * @param udi the udi of the device object
+ * @param options a list of additional options (none currently supported)
+ * @param cb_func an optional callback to call when the eject is done
+ * @param data cuatom data pointer for the callback function
+ */
+EAPI DBusPendingCall *
+e_udisks_volume_eject(E_DBus_Connection *conn, const char *udi, Eina_List *options, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusMessageIter iter, subiter;
+ Eina_List *l;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_device_call_new(udi, "DriveEject");
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter) ;
+
+ ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/* EnumerateDevices */
+EAPI DBusPendingCall *
+e_udisks_get_all_devices(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "EnumerateDevices");
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_string_list, cb_func, free_string_list, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+
+/* Manager.FindDeviceByCapability */
+/*
+ * not implemented in udisks yet...
+ *
+EAPI DBusPendingCall *
+e_udisks_find_device_by_capability(E_DBus_Connection *conn, const char *capability, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_udisks_call_new("FindDeviceByCapability");
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID);
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_string_list, cb_func, free_string_list, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+*/
--- /dev/null
+#include <E_Ukit.h>
+#include "e_ukit_private.h"
+
+int _e_dbus_udev_log_dom = -1;
+int _e_dbus_udev_init_count = 0;
+
+EAPI int
+e_ukit_init(void)
+{
+ if (++_e_dbus_udev_init_count != 1)
+ return _e_dbus_udev_init_count;
+
+ if (!eina_init())
+ return --_e_dbus_udev_init_count;
+
+ _e_dbus_udev_log_dom = eina_log_domain_register
+ ("e_ukit", E_DBUS_COLOR_DEFAULT);
+ if (_e_dbus_udev_log_dom < 0)
+ {
+ EINA_LOG_ERR("Could not register 'e_ukit' log domain.");
+ goto shutdown_eina;
+ }
+
+ if (!e_dbus_init())
+ {
+ ERR("Could not initialize E_DBus.");
+ goto unregister_log_domain;
+ }
+
+ return _e_dbus_udev_init_count;
+
+ unregister_log_domain:
+ eina_log_domain_unregister(_e_dbus_udev_log_dom);
+ _e_dbus_udev_log_dom = -1;
+ shutdown_eina:
+ eina_shutdown();
+
+ return _e_dbus_udev_init_count;
+}
+
+EAPI int
+e_ukit_shutdown(void)
+{
+ if (--_e_dbus_udev_init_count != 0)
+ return _e_dbus_udev_init_count;
+
+ e_dbus_shutdown();
+
+ eina_log_domain_unregister(_e_dbus_udev_log_dom);
+ _e_dbus_udev_log_dom = -1;
+ eina_shutdown();
+
+ return _e_dbus_udev_init_count;
+}
--- /dev/null
+#ifndef E_UKIT_PRIVATE_H
+#define E_UKIT_PRIVATE_H
+
+#ifndef E_DBUS_COLOR_DEFAULT
+#define E_DBUS_COLOR_DEFAULT EINA_COLOR_CYAN
+#endif
+extern int _e_dbus_udev_log_dom;
+#ifdef ERR
+#undef ERR
+#endif
+#ifdef INF
+#undef INF
+#endif
+#ifdef WARN
+#undef WARN
+#endif
+#ifdef DBG
+#undef DBG
+#endif
+
+#define e_ukit_call_new(udi, member) dbus_message_new_method_call(E_UKIT_BUS, udi, E_UKIT_BUS, member)
+#define e_ukit_device_call_new(udi, member) dbus_message_new_method_call(E_UKIT_BUS, udi, E_UKIT_INTERFACE, member)
+#define e_ukit_property_call_new(udi, member) dbus_message_new_method_call(E_UKIT_BUS, udi, E_UKIT_PROP_INTERFACE, member)
+
+#define DBG(...) EINA_LOG_DOM_DBG(_e_dbus_udev_log_dom, __VA_ARGS__)
+#define INFO(...) EINA_LOG_DOM_INFO(_e_dbus_udev_log_dom, __VA_ARGS__)
+#define WARN(...) EINA_LOG_DOM_WARN(_e_dbus_udev_log_dom, __VA_ARGS__)
+#define ERR(...) EINA_LOG_DOM_ERR(_e_dbus_udev_log_dom, __VA_ARGS__)
+
+#include "e_ukit_privfunc.h"
+
+#endif
--- /dev/null
+#ifndef E_UKIT_PRIVFUNC_H
+#define E_UKIT_PRIVFUNC_H
+
+
+static void *
+unmarshal_property(DBusMessage *msg, DBusError *err)
+{
+ E_Ukit_Get_Property_Return *ret = NULL;
+ DBusMessageIter iter, a_iter;
+ int type;
+ char *tmp;
+
+ ret = calloc(1, sizeof(E_Ukit_Get_Property_Return));
+ if (!ret)
+ {
+ dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
+ return NULL;
+ }
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &a_iter);
+ if (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+ {
+ type = dbus_message_iter_get_arg_type(&a_iter);
+
+ switch(type)
+ {
+ case DBUS_TYPE_STRING:
+ ret->type = E_UKIT_PROPERTY_TYPE_STRING;
+ dbus_message_iter_get_basic(&a_iter, &tmp);
+ ret->val.s = eina_stringshare_add(tmp);
+ break;
+ case DBUS_TYPE_INT32:
+ ret->type = E_UKIT_PROPERTY_TYPE_INT;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.i));
+ break;
+ case DBUS_TYPE_UINT32:
+ ret->type = E_UKIT_PROPERTY_TYPE_UINT32;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.u));
+ break;
+ case DBUS_TYPE_UINT64:
+ ret->type = E_UKIT_PROPERTY_TYPE_UINT64;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.t));
+ break;
+ case DBUS_TYPE_INT64:
+ ret->type = E_UKIT_PROPERTY_TYPE_INT64;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.x));
+ break;
+ case DBUS_TYPE_BOOLEAN:
+ ret->type = E_UKIT_PROPERTY_TYPE_BOOL;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.b));
+ break;
+ case DBUS_TYPE_DOUBLE:
+ ret->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
+ dbus_message_iter_get_basic(&a_iter, &(ret->val.d));
+ break;
+ case DBUS_TYPE_ARRAY:
+ ret->type = E_UKIT_PROPERTY_TYPE_STRLIST;
+ {
+ DBusMessageIter list_iter;
+ ret->val.strlist = NULL;
+ dbus_message_iter_recurse(&a_iter, &list_iter);
+ while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
+ {
+ char *str;
+ dbus_message_iter_get_basic(&list_iter, &str);
+ tmp = (char*)eina_stringshare_add(str);
+ ret->val.strlist = eina_list_append(ret->val.strlist, tmp);
+ dbus_message_iter_next(&list_iter);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ return ret;
+}
+
+
+
+static void
+free_property(void *data)
+{
+ E_Ukit_Get_Property_Return *ret = data;
+
+ if (!ret) return;
+ if (ret->type == E_UKIT_PROPERTY_TYPE_STRLIST)
+ {
+ const char *s;
+ EINA_LIST_FREE(ret->val.strlist, s)
+ eina_stringshare_del(s);
+ }
+ else if (ret->type == E_UKIT_PROPERTY_TYPE_STRING)
+ eina_stringshare_del(ret->val.s);
+ free(ret);
+}
+
+static void *
+unmarshal_device_get_all_properties(DBusMessage *msg, DBusError *err)
+{
+ E_Ukit_Get_All_Properties_Return *ret = NULL;
+ DBusMessageIter iter, a_iter, s_iter, v_iter;
+ int type;
+ char *tmp;
+
+ /* a{sv} = array of string+variants */
+ if (!dbus_message_has_signature(msg, "a{sv}"))
+ {
+ dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
+ return NULL;
+ }
+
+ ret = calloc(1, sizeof(E_Ukit_Get_All_Properties_Return));
+ if (!ret)
+ {
+ dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
+ return NULL;
+ }
+
+ ret->properties = eina_hash_string_small_new(EINA_FREE_CB(e_ukit_property_free));
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &a_iter);
+ while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+ {
+ const char *name;
+ E_Ukit_Property *prop = calloc(1, sizeof(E_Ukit_Property));
+ dbus_message_iter_recurse(&a_iter, &s_iter);
+ dbus_message_iter_get_basic(&s_iter, &name);
+ dbus_message_iter_next(&s_iter);
+ dbus_message_iter_recurse(&s_iter, &v_iter);
+
+ type = dbus_message_iter_get_arg_type(&v_iter);
+ switch(type)
+ {
+ case DBUS_TYPE_STRING:
+ prop->type = E_UKIT_PROPERTY_TYPE_STRING;
+ dbus_message_iter_get_basic(&v_iter, &tmp);
+ prop->val.s = eina_stringshare_add(tmp);
+ break;
+ case DBUS_TYPE_INT32:
+ prop->type = E_UKIT_PROPERTY_TYPE_INT;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.i));
+ break;
+ case DBUS_TYPE_UINT32:
+ prop->type = E_UKIT_PROPERTY_TYPE_UINT32;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.u));
+ break;
+ case DBUS_TYPE_UINT64:
+ prop->type = E_UKIT_PROPERTY_TYPE_UINT64;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.t));
+ break;
+ case DBUS_TYPE_INT64:
+ prop->type = E_UKIT_PROPERTY_TYPE_INT64;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.x));
+ break;
+ case DBUS_TYPE_BOOLEAN:
+ prop->type = E_UKIT_PROPERTY_TYPE_BOOL;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.b));
+ break;
+ case DBUS_TYPE_DOUBLE:
+ prop->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
+ dbus_message_iter_get_basic(&v_iter, &(prop->val.d));
+ break;
+ case DBUS_TYPE_ARRAY:
+ prop->type = E_UKIT_PROPERTY_TYPE_STRLIST;
+ {
+ DBusMessageIter list_iter;
+ prop->val.strlist = NULL;
+ dbus_message_iter_recurse(&v_iter, &list_iter);
+ while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
+ {
+ char *str;
+ dbus_message_iter_get_basic(&list_iter, &str);
+ tmp = (char*)eina_stringshare_add(str);
+ prop->val.strlist = eina_list_append(prop->val.strlist, tmp);
+ dbus_message_iter_next(&list_iter);
+ }
+ }
+ break;
+ default:
+ WARN("EUdev Error: unexpected property type (%s): %c", name, dbus_message_iter_get_arg_type(&v_iter));
+ break;
+ }
+ eina_hash_add(ret->properties, name, prop);
+
+ dbus_message_iter_next(&a_iter);
+ }
+
+ return ret;
+}
+
+static void
+free_device_get_all_properties(void *data)
+{
+ E_Ukit_Get_All_Properties_Return *ret = data;
+
+ if (!ret) return;
+ eina_hash_free(ret->properties);
+ free(ret);
+}
+
+static void *
+unmarshal_string_list(DBusMessage *msg, DBusError *err)
+{
+ E_Ukit_String_List_Return *ret = NULL;
+ DBusMessageIter iter, sub;
+ char *tmp;
+
+ /* ao = array of object strings */
+ if (!dbus_message_has_signature(msg, "ao"))
+ {
+ dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
+ return NULL;
+ }
+
+ ret = calloc(1, sizeof(E_Ukit_String_List_Return));
+ if (!ret)
+ {
+ dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
+ return NULL;
+ }
+
+ ret->strings = NULL;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &sub);
+ while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID)
+ {
+ char *dev = NULL;
+
+ dbus_message_iter_get_basic(&sub, &dev);
+ tmp = (char*)eina_stringshare_add(dev);
+ if (dev) ret->strings = eina_list_append(ret->strings, tmp);
+ dbus_message_iter_next(&sub);
+ }
+
+ return ret;
+}
+
+static void
+free_string_list(void *data)
+{
+ E_Ukit_String_List_Return *ret = data;
+ const char *x;
+
+ if (!ret) return;
+ EINA_LIST_FREE(ret->strings, x)
+ eina_stringshare_del(x);
+ free(ret);
+}
+
+
+#endif
--- /dev/null
+#include <E_Ukit.h>
+#include "e_ukit_private.h"
+
+/**
+ * @internal
+ * @brief free a property structure
+ * @param prop the property to free
+ */
+EAPI void
+e_ukit_property_free(E_Ukit_Property *prop)
+{
+ if (prop->type == E_UKIT_PROPERTY_TYPE_STRLIST)
+ eina_list_free(prop->val.strlist);
+ free(prop);
+}
+
+/**
+ * @brief Retrive a string from an element of a property hash
+ * @param properties the E_Ukit_Properties structure
+ * @param key the key of the property to retrieve
+ * @param err a pointer to an int, which if supplied, will be set to 0 on success and 1 on an error
+ */
+EAPI const char *
+e_ukit_property_string_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return NULL;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.s;
+
+ if (err) *err = 1;
+ return NULL;
+}
+
+EAPI Eina_Bool
+e_ukit_property_bool_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.b;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI int
+e_ukit_property_int_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.i;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI uint32_t
+e_ukit_property_uint32_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.u;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI uint64_t
+e_ukit_property_uint64_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.t;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI int64_t
+e_ukit_property_int64_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.x;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI double
+e_ukit_property_double_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return 0;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.d;
+
+ if (err) *err = 1;
+ return 0;
+}
+
+EAPI const Eina_List *
+e_ukit_property_strlist_get(E_Ukit_Properties *properties, const char *key, int *err)
+{
+ E_Ukit_Property *prop;
+ if (err) *err = 0;
+ if (!properties->properties) return NULL;
+ prop = eina_hash_find(properties->properties, key);
+ if (prop) return prop->val.strlist;
+
+ if (err) *err = 1;
+ return NULL;
+}
--- /dev/null
+#include <E_Ukit.h>
+#include "e_ukit_private.h"
+
+#define E_UKIT_BUS E_UPOWER_BUS
+#define E_UKIT_PATH E_UPOWER_PATH
+#define E_UKIT_INTERFACE E_UPOWER_INTERFACE
+
+const char *e_upower_iface="org.freedesktop.UPower.Device";
+
+#if 0
+static void cb_device_get_property(void *data, DBusMessage *msg, DBusError *err);
+static void cb_device_get_all_properties(void *data, DBusMessage *msg, DBusError *err);
+static void cb_device_query_capability(void *data, DBusMessage *msg, DBusError *err);
+#endif
+
+/* Properties.Get */
+EAPI DBusPendingCall *
+e_upower_get_property(E_DBus_Connection *conn, const char *udi, const char *property, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_property_call_new(udi, "Get");
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &e_upower_iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID);
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_property, cb_func, free_property, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/* Properties.GetAll */
+EAPI DBusPendingCall *
+e_upower_get_all_properties(E_DBus_Connection *conn, const char *udi, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_property_call_new(udi, "GetAll");
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &e_upower_iface, DBUS_TYPE_INVALID);
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_device_get_all_properties, cb_func, free_device_get_all_properties, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+
+EAPI DBusPendingCall *
+e_upower_hibernate(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "Hibernate");
+
+ ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+EAPI DBusPendingCall *
+e_upower_suspend(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "Suspend");
+
+ ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+EAPI DBusPendingCall *
+e_upower_hibernate_allowed(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "HibernateAllowed");
+
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_property, cb_func, free_property, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+EAPI DBusPendingCall *
+e_upower_suspend_allowed(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "SuspendAllowed");
+
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_property, cb_func, free_property, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
+
+/* EnumerateDevices */
+EAPI DBusPendingCall *
+e_upower_get_all_devices(E_DBus_Connection *conn, E_DBus_Callback_Func cb_func, void *data)
+{
+ DBusMessage *msg;
+ DBusPendingCall *ret;
+
+ msg = e_ukit_call_new(E_UKIT_PATH, "EnumerateDevices");
+ ret = e_dbus_method_call_send(conn, msg, unmarshal_string_list, cb_func, free_string_list, -1, data);
+ dbus_message_unref(msg);
+ return ret;
+}
projects / framework / uifw / edbus.git / commitdiff