diff --git a/ChangeLog b/ChangeLog index 5c8a5e6c2..a93d47af4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -303,9 +303,9 @@ 2013-01-03 José Roberto de Souza - * Modules ported to edbus: battery, connman, mixer, notification, + * Modules ported to eldbus: battery, connman, mixer, notification, illume-indicator - * Fileman and Wizard also ported to edbus + * Fileman and Wizard also ported to eldbus * HAL backend for EFM removed * Systray: added DBus notification * Added music-control module: control any mpris2-compatible music diff --git a/configure.ac b/configure.ac index 11e0b9ed0..1d6fecdb9 100644 --- a/configure.ac +++ b/configure.ac @@ -467,7 +467,7 @@ ecore-file >= $efl_version \ ecore-ipc >= $efl_version \ eet >= $efl_version \ efreet >= $efl_version \ -edbus2 >= $efl_version \ +eldbus >= $efl_version \ eina >= $efl_version" efm_requires="$efm_requires $eeze_mount $dbus_mount $udisks_mount" @@ -477,7 +477,7 @@ PKG_CHECK_MODULES(E_FM_CMDLINE, [ eina >= ${efl_version} ecore >= ${efl_version} ecore-file >= ${efl_version} - edbus2 >= ${efl_version} + eldbus >= ${efl_version} efreet >= ${efl_version} ]) @@ -535,7 +535,7 @@ PKG_CHECK_MODULES(E, [ efreet-mime >= ${efl_version} efreet-trash >= ${efl_version} eina >= ${efl_version} - edbus2 >= ${efl_version} + eldbus >= ${efl_version} eio >= ${efl_version} $eeze_mount $udisks_mount @@ -555,7 +555,7 @@ efreet >= ${efl_version} \ efreet-mime >= ${efl_version} \ efreet-trash >= ${efl_version} \ eina >= ${efl_version} \ -edbus2 \ +eldbus \ eio >= ${efl_version} \ $udisks_mount \ $eeze_mount \ @@ -688,7 +688,7 @@ define([CHECK_MODULE_TEMPERATURE], AM_CONDITIONAL(MUSIC_CONTROL, false) define([CHECK_MODULE_MUSIC_CONTROL], [ - AC_E_CHECK_PKG(MUSIC_CONTROL, [ ecore >= $efl_version eina >= $efl_version edbus2 ], [], [MUSIC_CONTROL=false]) + AC_E_CHECK_PKG(MUSIC_CONTROL, [ ecore >= $efl_version eina >= $efl_version eldbus ], [], [MUSIC_CONTROL=false]) ]) ##have_exchange=no @@ -717,7 +717,7 @@ AC_ARG_ENABLE([enotify], AC_CACHE_VAL([e_cv_want_enotify], [e_cv_want_enotify=yes]) ) if test "x$e_cv_want_enotify" != "xno" ; then - AC_E_CHECK_PKG(ENOTIFY, [ edbus2 >= $efl_version ], + AC_E_CHECK_PKG(ENOTIFY, [ eldbus >= $efl_version ], [ AC_DEFINE_UNQUOTED([HAVE_ENOTIFY], [1], [enable enotify]) ], @@ -803,7 +803,7 @@ AM_CONDITIONAL(HAVE_ECONNMAN, false) AM_CONDITIONAL(HAVE_DUMMY, false) define([CHECK_MODULE_CONNMAN], [ - AC_E_CHECK_PKG(ECONNMAN, [ edbus2 >= $efl_version ], [], [CONNMAN=false]) + AC_E_CHECK_PKG(ECONNMAN, [ eldbus >= $efl_version ], [], [CONNMAN=false]) dnl AC_E_CHECK_PKG(DUMMY, [ connman >= 1.0 ], [], [CONNMAN=false]) ]) AC_SUBST(ECONNMAN_CFLAGS) @@ -813,7 +813,7 @@ AM_CONDITIONAL(HAVE_BLUEZ4, false) AM_CONDITIONAL(HAVE_DUMMY, false) define([CHECK_MODULE_BLUEZ4], [ - AC_E_CHECK_PKG(BLUEZ4, [ edbus2 ],) + AC_E_CHECK_PKG(BLUEZ4, [ eldbus ],) ]) AC_SUBST(EBLUEZ4_CFLAGS) AC_SUBST(EBLUEZ4_LIBS) diff --git a/src/bin/e.h b/src/bin/e.h index 314cd326e..4ecc03c33 100644 --- a/src/bin/e.h +++ b/src/bin/e.h @@ -114,7 +114,7 @@ void *alloca (size_t); # include # include # include -# include +# include # include # ifdef HAVE_HAL diff --git a/src/bin/e_dbusmenu.c b/src/bin/e_dbusmenu.c index c8dbcbd4e..c186ee953 100644 --- a/src/bin/e_dbusmenu.c +++ b/src/bin/e_dbusmenu.c @@ -4,7 +4,7 @@ struct _E_DBusMenu_Ctx { - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; E_DBusMenu_Item *root_menu; void *data; E_DBusMenu_Pop_Request_Cb pop_request_cb; @@ -45,7 +45,7 @@ id_find(const char *text, const char *array_of_names[], unsigned max) } static void -dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) +dbus_menu_prop_dict_cb(void *data, const void *key, Eldbus_Message_Iter *var) { E_DBusMenu_Item *m = data; if (!strcmp(key, "label")) @@ -54,7 +54,7 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) Eina_Strbuf *label_buf = eina_strbuf_new(); int i; - edbus_message_iter_arguments_get(var, "s", &label); + eldbus_message_iter_arguments_get(var, "s", &label); for (i = 0; label[i]; i++) { if (label[i] != '_') @@ -76,17 +76,17 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) else if (!strcmp(key, "type")) { const char *type; - edbus_message_iter_arguments_get(var, "s", &type); + eldbus_message_iter_arguments_get(var, "s", &type); m->type = id_find(type, Menu_Item_Type_Names, E_DBUSMENU_ITEM_TYPE_LAST); } else if (!strcmp(key, "icon-data")) { - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; int size; const unsigned char *img_data; - edbus_message_iter_arguments_get(var, "ay", &array); - edbus_message_iter_fixed_array_get(array, 'y', &img_data, &size); + eldbus_message_iter_arguments_get(var, "ay", &array); + eldbus_message_iter_fixed_array_get(array, 'y', &img_data, &size); if (!size) return; m->icon_data = malloc(sizeof(unsigned char) * size); @@ -97,20 +97,20 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) else if (!strcmp(key, "icon-name")) { const char *icon_name; - edbus_message_iter_arguments_get(var, "s", &icon_name); + eldbus_message_iter_arguments_get(var, "s", &icon_name); eina_stringshare_replace(&m->icon_name, icon_name); } else if (!strcmp(key, "toggle-type")) { const char *toggle_type; - edbus_message_iter_arguments_get(var, "s", &toggle_type); + eldbus_message_iter_arguments_get(var, "s", &toggle_type); m->toggle_type = id_find(toggle_type, Menu_Item_Toggle_Type_Names, E_DBUSMENU_ITEM_TOGGLE_TYPE_LAST); } else if (!strcmp(key, "toggle-state")) { int state; - edbus_message_iter_arguments_get(var, "i", &state); + eldbus_message_iter_arguments_get(var, "i", &state); if (state == 1) m->toggle_state = EINA_TRUE; else @@ -119,7 +119,7 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) else if (!strcmp(key, "children-display")) { const char *display; - edbus_message_iter_arguments_get(var, "s", &display); + eldbus_message_iter_arguments_get(var, "s", &display); if (!strcmp(display, "submenu")) m->is_submenu = EINA_TRUE; else @@ -128,27 +128,27 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var) else if (!strcmp(key, "disposition")) { const char *disposition; - edbus_message_iter_arguments_get(var, "s", &disposition); + eldbus_message_iter_arguments_get(var, "s", &disposition); m->disposition = id_find(disposition, Menu_Item_Dispostion_Names, E_DBUSMENU_ITEM_DISPOSTION_LAST); } else if (!strcmp(key, "enabled")) - edbus_message_iter_arguments_get(var, "b", &m->enabled); + eldbus_message_iter_arguments_get(var, "b", &m->enabled); else if (!strcmp(key, "visible")) - edbus_message_iter_arguments_get(var, "b", &m->visible); + eldbus_message_iter_arguments_get(var, "b", &m->visible); } static E_DBusMenu_Item * -parse_layout(EDBus_Message_Iter *layout, E_DBusMenu_Item *parent, E_DBusMenu_Ctx *ctx) +parse_layout(Eldbus_Message_Iter *layout, E_DBusMenu_Item *parent, E_DBusMenu_Ctx *ctx) { - EDBus_Message_Iter *menu_item_prop, *sub_menu_items_prop, *var; + Eldbus_Message_Iter *menu_item_prop, *sub_menu_items_prop, *var; E_DBusMenu_Item *m = calloc(1, sizeof(E_DBusMenu_Item)); EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL); m->ctx = ctx; m->enabled = EINA_TRUE; m->visible = EINA_TRUE; - if (!edbus_message_iter_arguments_get(layout, "ia{sv}av", &m->id, + if (!eldbus_message_iter_arguments_get(layout, "ia{sv}av", &m->id, &menu_item_prop, &sub_menu_items_prop)) { ERR("Error reading message"); @@ -156,12 +156,12 @@ parse_layout(EDBus_Message_Iter *layout, E_DBusMenu_Item *parent, E_DBusMenu_Ctx return NULL; } - edbus_message_iter_dict_iterate(menu_item_prop, "sv", dbus_menu_prop_dict_cb, m); + eldbus_message_iter_dict_iterate(menu_item_prop, "sv", dbus_menu_prop_dict_cb, m); - while (edbus_message_iter_get_and_next(sub_menu_items_prop, 'v', &var)) + while (eldbus_message_iter_get_and_next(sub_menu_items_prop, 'v', &var)) { - EDBus_Message_Iter *st; - if (!edbus_message_iter_arguments_get(var, "(ia{sv}av)", &st)) + Eldbus_Message_Iter *st; + if (!eldbus_message_iter_arguments_get(var, "(ia{sv}av)", &st)) { ERR("Error readding message."); continue; @@ -198,21 +198,21 @@ dbus_menu_free(E_DBusMenu_Item *m) } static void -layout_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +layout_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { E_DBusMenu_Item *m; const char *error, *error_msg; - EDBus_Message_Iter *layout; + Eldbus_Message_Iter *layout; unsigned revision; E_DBusMenu_Ctx *ctx = data; - if (edbus_message_error_get(msg, &error, &error_msg)) + if (eldbus_message_error_get(msg, &error, &error_msg)) { ERR("%s %s", error, error_msg); return; } - if (!edbus_message_arguments_get(msg, "u(ia{sv}av)", &revision, &layout)) + if (!eldbus_message_arguments_get(msg, "u(ia{sv}av)", &revision, &layout)) { ERR("Error reading message"); return; @@ -250,14 +250,14 @@ dbus_menu_find(E_DBusMenu_Ctx *ctx, int id) } static void -menu_pop_request(void *data, const EDBus_Message *msg) +menu_pop_request(void *data, const Eldbus_Message *msg) { E_DBusMenu_Ctx *ctx = data; int id; unsigned timestamp; E_DBusMenu_Item *m; - if (!edbus_message_arguments_get(msg, "iu", &id, ×tamp)) + if (!eldbus_message_arguments_get(msg, "iu", &id, ×tamp)) { ERR("Error reading values."); return; @@ -271,38 +271,38 @@ menu_pop_request(void *data, const EDBus_Message *msg) } static void -icon_theme_path_get_cb(void *data EINA_UNUSED, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +icon_theme_path_get_cb(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { const char *error, *error_msg; - EDBus_Message_Iter *var, *array; + Eldbus_Message_Iter *var, *array; const char *path; - if (edbus_message_error_get(msg, &error, &error_msg)) + if (eldbus_message_error_get(msg, &error, &error_msg)) { ERR("%s %s", error, error_msg); return; } - if (!edbus_message_arguments_get(msg, "v", &var) || - !edbus_message_iter_arguments_get(var, "as", &array)) + if (!eldbus_message_arguments_get(msg, "v", &var) || + !eldbus_message_iter_arguments_get(var, "as", &array)) { ERR("Error reading message."); return; } - while (edbus_message_iter_get_and_next(array, 's', &path)) + while (eldbus_message_iter_get_and_next(array, 's', &path)) { //TODO } } static void -prop_changed_cb(void *data EINA_UNUSED, const EDBus_Message *msg) +prop_changed_cb(void *data EINA_UNUSED, const Eldbus_Message *msg) { const char *interface, *propname; - EDBus_Message_Iter *variant, *array; + Eldbus_Message_Iter *variant, *array; - if (!edbus_message_arguments_get(msg, "ssv", &interface, &propname, &variant)) + if (!eldbus_message_arguments_get(msg, "ssv", &interface, &propname, &variant)) { ERR("Error getting values"); return; @@ -311,7 +311,7 @@ prop_changed_cb(void *data EINA_UNUSED, const EDBus_Message *msg) if (strcmp(propname, "IconThemePath")) return; - if (!edbus_message_iter_arguments_get(variant, "as", &array)) + if (!eldbus_message_iter_arguments_get(variant, "as", &array)) { //TODO } @@ -320,27 +320,27 @@ prop_changed_cb(void *data EINA_UNUSED, const EDBus_Message *msg) static void layout_update(E_DBusMenu_Ctx *ctx) { - EDBus_Message *msg; - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message *msg; + Eldbus_Message_Iter *main_iter, *array; - msg = edbus_proxy_method_call_new(ctx->proxy, "GetLayout"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_arguments_append(main_iter, "iias", 0, -1, &array); - edbus_message_iter_container_close(main_iter, array); - edbus_proxy_send(ctx->proxy, msg, layout_get_cb, ctx, -1); + msg = eldbus_proxy_method_call_new(ctx->proxy, "GetLayout"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_arguments_append(main_iter, "iias", 0, -1, &array); + eldbus_message_iter_container_close(main_iter, array); + eldbus_proxy_send(ctx->proxy, msg, layout_get_cb, ctx, -1); } static void -layout_updated_cb(void *data, const EDBus_Message *msg EINA_UNUSED) +layout_updated_cb(void *data, const Eldbus_Message *msg EINA_UNUSED) { E_DBusMenu_Ctx *ctx = data; layout_update(ctx); } EAPI E_DBusMenu_Ctx * -e_dbusmenu_load(EDBus_Connection *conn, const char *bus, const char *path, const void *data) +e_dbusmenu_load(Eldbus_Connection *conn, const char *bus, const char *path, const void *data) { - EDBus_Object *obj; + Eldbus_Object *obj; E_DBusMenu_Ctx *ctx; EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL); @@ -350,23 +350,23 @@ e_dbusmenu_load(EDBus_Connection *conn, const char *bus, const char *path, const ctx->data = (void *)data; - edbus_connection_ref(conn); - obj = edbus_object_get(conn, bus, path); - ctx->proxy = edbus_proxy_get(obj, DBUS_MENU_IFACE); + eldbus_connection_ref(conn); + obj = eldbus_object_get(conn, bus, path); + ctx->proxy = eldbus_proxy_get(obj, DBUS_MENU_IFACE); layout_update(ctx); - edbus_proxy_signal_handler_add(ctx->proxy, + eldbus_proxy_signal_handler_add(ctx->proxy, "ItemActivationRequested", menu_pop_request, ctx); - edbus_proxy_property_get(ctx->proxy, "IconThemePath", + eldbus_proxy_property_get(ctx->proxy, "IconThemePath", icon_theme_path_get_cb, ctx); - edbus_proxy_properties_changed_callback_add(ctx->proxy, + eldbus_proxy_properties_changed_callback_add(ctx->proxy, prop_changed_cb, ctx); - edbus_proxy_signal_handler_add(ctx->proxy, "ItemsPropertiesUpdated", + eldbus_proxy_signal_handler_add(ctx->proxy, "ItemsPropertiesUpdated", layout_updated_cb, ctx); - edbus_proxy_signal_handler_add(ctx->proxy, "LayoutUpdated", + eldbus_proxy_signal_handler_add(ctx->proxy, "LayoutUpdated", layout_updated_cb, ctx); return ctx; } @@ -374,44 +374,44 @@ e_dbusmenu_load(EDBus_Connection *conn, const char *bus, const char *path, const EAPI void e_dbusmenu_event_send(E_DBusMenu_Item *m, E_DBusMenu_Item_Event event) { - EDBus_Message *msg; - EDBus_Message_Iter *main_iter, *var; + Eldbus_Message *msg; + Eldbus_Message_Iter *main_iter, *var; unsigned int timestamp = (unsigned int)time(NULL); EINA_SAFETY_ON_NULL_RETURN(m); EINA_SAFETY_ON_FALSE_RETURN(event < E_DBUSMENU_ITEM_EVENT_LAST); EINA_SAFETY_ON_NULL_RETURN(m->ctx); - msg = edbus_proxy_method_call_new(m->ctx->proxy, "Event"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_arguments_append(main_iter, "is", m->id, + msg = eldbus_proxy_method_call_new(m->ctx->proxy, "Event"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_arguments_append(main_iter, "is", m->id, Menu_Item_Event_Names[event]); - var = edbus_message_iter_container_new(main_iter, 'v', "s"); + var = eldbus_message_iter_container_new(main_iter, 'v', "s"); /* dummy data */ - edbus_message_iter_arguments_append(var, "s", ""); - edbus_message_iter_container_close(main_iter, var); + eldbus_message_iter_arguments_append(var, "s", ""); + eldbus_message_iter_container_close(main_iter, var); - edbus_message_iter_arguments_append(main_iter, "u", timestamp); + eldbus_message_iter_arguments_append(main_iter, "u", timestamp); - edbus_proxy_send(m->ctx->proxy, msg, NULL, NULL, -1); - edbus_message_unref(msg); + eldbus_proxy_send(m->ctx->proxy, msg, NULL, NULL, -1); + eldbus_message_unref(msg); } EAPI void e_dbusmenu_unload(E_DBusMenu_Ctx *ctx) { - EDBus_Connection *conn; - EDBus_Object *obj; + Eldbus_Connection *conn; + Eldbus_Object *obj; EINA_SAFETY_ON_NULL_RETURN(ctx); if (ctx->root_menu) dbus_menu_free(ctx->root_menu); - obj = edbus_proxy_object_get(ctx->proxy); - conn = edbus_object_connection_get(obj); - edbus_proxy_unref(ctx->proxy); - edbus_object_unref(obj); - edbus_connection_unref(conn); + obj = eldbus_proxy_object_get(ctx->proxy); + conn = eldbus_object_connection_get(obj); + eldbus_proxy_unref(ctx->proxy); + eldbus_object_unref(obj); + eldbus_connection_unref(conn); free(ctx); } diff --git a/src/bin/e_dbusmenu.h b/src/bin/e_dbusmenu.h index 133c1950c..84005ffef 100644 --- a/src/bin/e_dbusmenu.h +++ b/src/bin/e_dbusmenu.h @@ -2,7 +2,7 @@ #define _E_DBUSMENU_H_ #include -#include +#include typedef enum { E_DBUSMENU_ITEM_TYPE_STANDARD = 0, @@ -61,7 +61,7 @@ struct _E_DBusMenu_Item typedef void (*E_DBusMenu_Pop_Request_Cb)(void *data, const E_DBusMenu_Item *item); typedef void (*E_DBusMenu_Update_Cb)(void *data, E_DBusMenu_Item *new_root_item); -EAPI E_DBusMenu_Ctx * e_dbusmenu_load(EDBus_Connection *conn, const char *bus, const char *path, const void *data); +EAPI E_DBusMenu_Ctx * e_dbusmenu_load(Eldbus_Connection *conn, const char *bus, const char *path, const void *data); EAPI void e_dbusmenu_unload(E_DBusMenu_Ctx *ctx); EAPI void e_dbusmenu_update_cb_set(E_DBusMenu_Ctx *menu_data, E_DBusMenu_Update_Cb cb); EAPI void e_dbusmenu_pop_request_cb_set(E_DBusMenu_Ctx *menu_data, E_DBusMenu_Pop_Request_Cb cb); diff --git a/src/bin/e_fm/e_fm_main.c b/src/bin/e_fm/e_fm_main.c index 6e670b5ed..3d45b063c 100644 --- a/src/bin/e_fm/e_fm_main.c +++ b/src/bin/e_fm/e_fm_main.c @@ -71,7 +71,7 @@ static Efm_Mode mode = EFM_MODE_USING_RASTER_MOUNT; /* FIXME: things to add to the slave enlightenment_fm process and ipc to e: * * * reporting results of fop's (current status - what has been don, what failed etc.) - * * dbus removable device monitoring (in e17 itself now via edbus - move to enlightenment_fm and ipc removable device add/del and anything else) + * * dbus removable device monitoring (in e17 itself now via eldbus - move to enlightenment_fm and ipc removable device add/del and anything else) * * mount/umount of removable devices (to go along with removable device support - put it in here and message back mount success/failure and where it is now mounted - remove from e17 itself) * */ diff --git a/src/bin/e_fm/e_fm_main_udisks.c b/src/bin/e_fm/e_fm_main_udisks.c index e6f09a228..1be01f8ac 100644 --- a/src/bin/e_fm/e_fm_main_udisks.c +++ b/src/bin/e_fm/e_fm_main_udisks.c @@ -45,7 +45,7 @@ void *alloca(size_t); #include #include #include -#include +#include #include "e_fm_shared_device.h" #include "e_fm_shared_codec.h" @@ -60,22 +60,22 @@ void *alloca(size_t); #define UDISKS_INTERFACE "org.freedesktop.UDisks" #define UDISKS_DEVICE_INTERFACE "org.freedesktop.UDisks.Device" -static EDBus_Connection *_e_fm_main_udisks_conn = NULL; -static EDBus_Proxy *_e_fm_main_udisks_proxy = NULL; +static Eldbus_Connection *_e_fm_main_udisks_conn = NULL; +static Eldbus_Proxy *_e_fm_main_udisks_proxy = NULL; static Eina_List *_e_stores = NULL; static Eina_List *_e_vols = NULL; -static void _e_fm_main_udisks_cb_dev_all(void *data, const EDBus_Message *msg, - EDBus_Pending *pending); -static void _e_fm_main_udisks_cb_dev_verify(void *data, const EDBus_Message *msg, - EDBus_Pending *pending); -static void _e_fm_main_udisks_cb_dev_add(void *data, const EDBus_Message *msg); -static void _e_fm_main_udisks_cb_dev_del(void *data, const EDBus_Message *msg); -static void _e_fm_main_udisks_cb_prop_modified(void *data, const EDBus_Message *msg); -static void _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, - EDBus_Pending *pending); -static void _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, - EDBus_Pending *pending); +static void _e_fm_main_udisks_cb_dev_all(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending); +static void _e_fm_main_udisks_cb_dev_verify(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending); +static void _e_fm_main_udisks_cb_dev_add(void *data, const Eldbus_Message *msg); +static void _e_fm_main_udisks_cb_dev_del(void *data, const Eldbus_Message *msg); +static void _e_fm_main_udisks_cb_prop_modified(void *data, const Eldbus_Message *msg); +static void _e_fm_main_udisks_cb_store_prop(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending); +static void _e_fm_main_udisks_cb_vol_prop(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending); static void _e_fm_main_udisks_cb_vol_mounted(E_Volume *v); static void _e_fm_main_udisks_cb_vol_unmounted(E_Volume *v); static void _e_fm_main_udisks_cb_vol_unmounted_before_eject(E_Volume *v); @@ -95,56 +95,56 @@ static E_Volume *_volume_find_by_dbus_path(const char *path); static void _volume_del(E_Volume *v); static void -_e_fm_main_udisks_name_start(void *data __UNUSED__, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_name_start(void *data __UNUSED__, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { unsigned flag = 0; - EDBus_Object *obj; + Eldbus_Object *obj; - if (!edbus_message_arguments_get(msg, "u", &flag) || !flag) + if (!eldbus_message_arguments_get(msg, "u", &flag) || !flag) { _e_fm_main_udisks_catch(EINA_FALSE); return; } - obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, UDISKS_PATH); - _e_fm_main_udisks_proxy = edbus_proxy_get(obj, UDISKS_INTERFACE); + obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, UDISKS_PATH); + _e_fm_main_udisks_proxy = eldbus_proxy_get(obj, UDISKS_INTERFACE); - edbus_proxy_call(_e_fm_main_udisks_proxy, "EnumerateDevices", + eldbus_proxy_call(_e_fm_main_udisks_proxy, "EnumerateDevices", _e_fm_main_udisks_cb_dev_all, NULL, -1, ""); - edbus_proxy_signal_handler_add(_e_fm_main_udisks_proxy, "DeviceAdded", + eldbus_proxy_signal_handler_add(_e_fm_main_udisks_proxy, "DeviceAdded", _e_fm_main_udisks_cb_dev_add, NULL); - edbus_proxy_signal_handler_add(_e_fm_main_udisks_proxy, "DeviceRemoved", + eldbus_proxy_signal_handler_add(_e_fm_main_udisks_proxy, "DeviceRemoved", _e_fm_main_udisks_cb_dev_del, NULL); _e_fm_main_udisks_catch(EINA_TRUE); /* signal usage of udisks for mounting */ } static void -_e_fm_main_udisks_cb_dev_all(void *data __UNUSED__, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_cb_dev_all(void *data __UNUSED__, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { const char *name, *txt, *path; - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; - if (edbus_message_error_get(msg, &name, &txt)) + if (eldbus_message_error_get(msg, &name, &txt)) { ERR("Error %s %s.", name, txt); return; } - if (!edbus_message_arguments_get(msg, "ao", &array)) + if (!eldbus_message_arguments_get(msg, "ao", &array)) { ERR("Error getting arguments."); return; } - while (edbus_message_iter_get_and_next(array, 'o', &path)) + while (eldbus_message_iter_get_and_next(array, 'o', &path)) { - EDBus_Message *new_msg; - new_msg = edbus_message_method_call_new(UDISKS_BUS, path, - EDBUS_FDO_INTERFACE_PROPERTIES, "Get"); - edbus_message_arguments_append(new_msg, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); - edbus_connection_send(_e_fm_main_udisks_conn, new_msg, + Eldbus_Message *new_msg; + new_msg = eldbus_message_method_call_new(UDISKS_BUS, path, + ELDBUS_FDO_INTERFACE_PROPERTIES, "Get"); + eldbus_message_arguments_append(new_msg, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); + eldbus_connection_send(_e_fm_main_udisks_conn, new_msg, _e_fm_main_udisks_cb_dev_verify, eina_stringshare_add(path), -1); INF("DB INIT DEV+: %s", path); @@ -153,25 +153,25 @@ _e_fm_main_udisks_cb_dev_all(void *data __UNUSED__, const EDBus_Message *msg, static void -_e_fm_main_udisks_cb_dev_verify(void *data, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_cb_dev_verify(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { const char *name, *txt, *id_usage, *path = data; - EDBus_Message_Iter *variant; + Eldbus_Message_Iter *variant; - if (edbus_message_error_get(msg, &name, &txt)) + if (eldbus_message_error_get(msg, &name, &txt)) { ERR("Error %s %s.", name, txt); goto error; } - if (!edbus_message_arguments_get(msg, "v", &variant)) + if (!eldbus_message_arguments_get(msg, "v", &variant)) { ERR("Error getting arguments."); goto error; } - if (!edbus_message_iter_arguments_get(variant, "s", &id_usage)) + if (!eldbus_message_iter_arguments_get(variant, "s", &id_usage)) { ERR("Type of variant not expected"); goto error; @@ -189,25 +189,25 @@ error: } static void -_e_fm_main_udisks_cb_dev_verify_added(void *data, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_cb_dev_verify_added(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { const char *name, *txt, *id_usage, *path = data; - EDBus_Message_Iter *variant; + Eldbus_Message_Iter *variant; - if (edbus_message_error_get(msg, &name, &txt)) + if (eldbus_message_error_get(msg, &name, &txt)) { ERR("Error %s %s.", name, txt); goto error; } - if (!edbus_message_arguments_get(msg, "v", &variant)) + if (!eldbus_message_arguments_get(msg, "v", &variant)) { ERR("Error getting arguments."); goto error; } - if (!edbus_message_iter_arguments_get(variant, "s", &id_usage)) + if (!eldbus_message_iter_arguments_get(variant, "s", &id_usage)) { ERR("Type of variant not expected"); goto error; @@ -221,7 +221,7 @@ _e_fm_main_udisks_cb_dev_verify_added(void *data, const EDBus_Message *msg, if (!s) _e_fm_main_udisks_storage_add(path); else - edbus_proxy_property_get_all(s->proxy, + eldbus_proxy_property_get_all(s->proxy, _e_fm_main_udisks_cb_store_prop, s); } else if(!strcmp(id_usage, "filesystem")) @@ -231,7 +231,7 @@ _e_fm_main_udisks_cb_dev_verify_added(void *data, const EDBus_Message *msg, if (!v) _e_fm_main_udisks_volume_add(path, EINA_TRUE); else - edbus_proxy_property_get_all(v->proxy, + eldbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); } else @@ -242,37 +242,37 @@ error: } static void -_e_fm_main_udisks_cb_dev_add(void *data __UNUSED__, const EDBus_Message *msg) +_e_fm_main_udisks_cb_dev_add(void *data __UNUSED__, const Eldbus_Message *msg) { - EDBus_Message *new; + Eldbus_Message *new; E_Volume *v; char *path; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; DBG("DB DEV+: %s", path); v = _volume_find_by_dbus_path(path); if (v) { - edbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); + eldbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); return; } - new = edbus_message_method_call_new(UDISKS_BUS, path, EDBUS_FDO_INTERFACE_PROPERTIES, "Get"); - edbus_message_arguments_append(new, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); - edbus_connection_send(_e_fm_main_udisks_conn, new, + new = eldbus_message_method_call_new(UDISKS_BUS, path, ELDBUS_FDO_INTERFACE_PROPERTIES, "Get"); + eldbus_message_arguments_append(new, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); + eldbus_connection_send(_e_fm_main_udisks_conn, new, _e_fm_main_udisks_cb_dev_verify_added, eina_stringshare_add(path), -1); } static void -_e_fm_main_udisks_cb_dev_del(void *data __UNUSED__, const EDBus_Message *msg) +_e_fm_main_udisks_cb_dev_del(void *data __UNUSED__, const Eldbus_Message *msg) { char *path; E_Volume *v; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; DBG("DB DEV-: %s", path); if ((v = _volume_find_by_dbus_path(path))) @@ -286,10 +286,10 @@ _e_fm_main_udisks_cb_dev_del(void *data __UNUSED__, const EDBus_Message *msg) static void _e_fm_main_udisks_cb_prop_modified(void *data, - const EDBus_Message *msg __UNUSED__) + const Eldbus_Message *msg __UNUSED__) { E_Volume *v = data; - edbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); + eldbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); } static Eina_Bool @@ -301,41 +301,41 @@ _storage_del(void *data) } static void -_e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_cb_store_prop(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { E_Storage *s = data; const char *name, *txt; - EDBus_Message_Iter *dict, *entry; + Eldbus_Message_Iter *dict, *entry; - if (edbus_message_error_get(msg, &name, &txt)) + if (eldbus_message_error_get(msg, &name, &txt)) { ERR("Error %s %s.", name, txt); return; } - if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &dict)) { ERR("Error getting arguments."); return; } - while (edbus_message_iter_get_and_next(dict, 'e', &entry)) + while (eldbus_message_iter_get_and_next(dict, 'e', &entry)) { char *key; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; - if (!edbus_message_iter_arguments_get(entry, "sv", &key, &var)) + if (!eldbus_message_iter_arguments_get(entry, "sv", &key, &var)) continue; if (!strcmp(key, "DeviceFile")) { const char *udi; - if (edbus_message_iter_arguments_get(var, "s", &udi)) + if (eldbus_message_iter_arguments_get(var, "s", &udi)) eina_stringshare_replace(&s->udi, udi); } else if (!strcmp(key, "DriveConnectionInterface")) { const char *bus; - if (edbus_message_iter_arguments_get(var, "s", &bus)) + if (eldbus_message_iter_arguments_get(var, "s", &bus)) { if (s->bus) eina_stringshare_del(bus); @@ -344,13 +344,13 @@ _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, } else if (!strcmp(key, "DriveMediaCompatibility")) { - EDBus_Message_Iter *inner_array; + Eldbus_Message_Iter *inner_array; const char *media; - if (!edbus_message_iter_arguments_get(var, "as", &inner_array)) + if (!eldbus_message_iter_arguments_get(var, "as", &inner_array)) continue; - while(edbus_message_iter_get_and_next(inner_array, 's', &media)) + while(eldbus_message_iter_get_and_next(inner_array, 's', &media)) { eina_stringshare_replace(&s->drive_type, media); break; @@ -359,13 +359,13 @@ _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "DriveModel")) { const char *model; - if (edbus_message_iter_arguments_get(var, "s", &model)) + if (eldbus_message_iter_arguments_get(var, "s", &model)) eina_stringshare_replace(&s->model, model); } else if (!strcmp(key, "DriveVendor")) { const char *vendor; - if (edbus_message_iter_arguments_get(var, "s", &vendor)) + if (eldbus_message_iter_arguments_get(var, "s", &vendor)) { if (s->vendor) eina_stringshare_del(s->vendor); @@ -375,7 +375,7 @@ _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "DriveSerial")) { const char *serial; - if (edbus_message_iter_arguments_get(var, "s", &serial)) + if (eldbus_message_iter_arguments_get(var, "s", &serial)) { if (s->serial) eina_stringshare_del(s->serial); @@ -383,21 +383,21 @@ _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, } } else if (!strcmp(key, "DeviceIsSystemInternal")) - edbus_message_iter_arguments_get(var, "b", &s->system_internal); + eldbus_message_iter_arguments_get(var, "b", &s->system_internal); else if (!strcmp(key, "DeviceIsMediaAvailable")) - edbus_message_iter_arguments_get(var, "b", &s->media_available); + eldbus_message_iter_arguments_get(var, "b", &s->media_available); else if (!strcmp(key, "DeviceSize")) - edbus_message_iter_arguments_get(var, "t", &s->media_size); + eldbus_message_iter_arguments_get(var, "t", &s->media_size); else if (!strcmp(key, "DriveIsMediaEjectable")) - edbus_message_iter_arguments_get(var, "b", &s->requires_eject); + eldbus_message_iter_arguments_get(var, "b", &s->requires_eject); else if (!strcmp(key, "DriveCanDetach")) - edbus_message_iter_arguments_get(var, "b", &s->hotpluggable); + eldbus_message_iter_arguments_get(var, "b", &s->hotpluggable); else if (!strcmp(key, "DeviceIsMediaChangeDetectionInhibited")) - edbus_message_iter_arguments_get(var, "b", &s->media_check_enabled); + eldbus_message_iter_arguments_get(var, "b", &s->media_check_enabled); else if (!strcmp(key, "DevicePresentationIconName")) { const char *icon; - if (edbus_message_iter_arguments_get(var, "s", &icon)) + if (eldbus_message_iter_arguments_get(var, "s", &icon)) { if (s->icon.drive) eina_stringshare_del(s->icon.drive); @@ -450,39 +450,39 @@ _idler_volume_del(void *data) } static void -_e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_fm_main_udisks_cb_vol_prop(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { E_Volume *v = data; E_Storage *s = NULL; const char *txt, *message; - EDBus_Message_Iter *array, *dict; + Eldbus_Message_Iter *array, *dict; DBG("volume=%s",v->dbus_path); - if (edbus_message_error_get(msg, &txt, &message)) + if (eldbus_message_error_get(msg, &txt, &message)) { ERR("Error: %s %s\nVolume: %s", txt, message, v->udi); return; } - if (!edbus_message_arguments_get(msg, "a{sv}", &array)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &array)) { ERR("Error getting values."); return; } - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *key; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var)) continue; if (!strcmp(key, "DeviceFile")) { const char *udi; - if (!edbus_message_iter_arguments_get(var, "s", &udi)) + if (!eldbus_message_iter_arguments_get(var, "s", &udi)) continue; if (udi && v->first_time) eina_stringshare_replace(&v->udi, udi); @@ -490,7 +490,7 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "DeviceIsSystemInternal")) { Eina_Bool internal; - edbus_message_iter_arguments_get(var, "b", &internal); + eldbus_message_iter_arguments_get(var, "b", &internal); if (internal) { DBG("removing is internal %s", v->dbus_path); @@ -501,7 +501,7 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "DeviceIsMediaChangeDetectionInhibited")) { Eina_Bool inibited; - edbus_message_iter_arguments_get(var, "b", &inibited); + eldbus_message_iter_arguments_get(var, "b", &inibited); if (inibited) { /* skip volumes with volume.ignore set */ @@ -511,30 +511,30 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, } } else if (!strcmp(key, "DeviceIsLuks")) - edbus_message_iter_arguments_get(var, "b", &v->encrypted); + eldbus_message_iter_arguments_get(var, "b", &v->encrypted); else if (!strcmp(key, "IdUuid")) { const char *uuid; - if (!edbus_message_iter_arguments_get(var, "s", &uuid)) + if (!eldbus_message_iter_arguments_get(var, "s", &uuid)) continue; eina_stringshare_replace(&v->uuid, uuid); } else if (!strcmp(key, "IdLabel")) { const char *label; - if (!edbus_message_iter_arguments_get(var, "s", &label)) + if (!eldbus_message_iter_arguments_get(var, "s", &label)) continue; eina_stringshare_replace(&v->label, label); } else if (!strcmp(key, "DeviceMountPaths")) { - EDBus_Message_Iter *inner_array; + Eldbus_Message_Iter *inner_array; const char *path; - if (!edbus_message_iter_arguments_get(var, "as", &inner_array)) + if (!eldbus_message_iter_arguments_get(var, "as", &inner_array)) continue; - while (edbus_message_iter_get_and_next(inner_array, 's', &path)) + while (eldbus_message_iter_get_and_next(inner_array, 's', &path)) { eina_stringshare_replace(&v->mount_point, path); break; @@ -543,24 +543,24 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "IdType")) { const char *type; - if (!edbus_message_iter_arguments_get(var, "s", &type)) + if (!eldbus_message_iter_arguments_get(var, "s", &type)) continue; eina_stringshare_replace(&v->fstype, type); } else if (!strcmp(key, "DeviceSize")) - edbus_message_iter_arguments_get(var, "t", &v->size); + eldbus_message_iter_arguments_get(var, "t", &v->size); else if (!strcmp(key, "DeviceIsMounted")) - edbus_message_iter_arguments_get(var, "b", &v->mounted); + eldbus_message_iter_arguments_get(var, "b", &v->mounted); else if (!strcmp(key, "DeviceIsLuksCleartext")) - edbus_message_iter_arguments_get(var, "b", &v->unlocked); + eldbus_message_iter_arguments_get(var, "b", &v->unlocked); else if (!strcmp(key, "DeviceIsPartition")) - edbus_message_iter_arguments_get(var, "b", &v->partition); + eldbus_message_iter_arguments_get(var, "b", &v->partition); else if (!strcmp(key, "PartitionNumber")) - edbus_message_iter_arguments_get(var, "i", &v->partition_number); + eldbus_message_iter_arguments_get(var, "i", &v->partition_number); else if (!strcmp(key, "PartitionLabel")) { const char *partition_label; - if (!edbus_message_iter_arguments_get(var, "s", &partition_label)) + if (!eldbus_message_iter_arguments_get(var, "s", &partition_label)) continue; eina_stringshare_replace(&v->partition_label, partition_label); } @@ -568,7 +568,7 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, { const char *enc; E_Volume *venc; - if (!edbus_message_iter_arguments_get(var, "o", &enc)) + if (!eldbus_message_iter_arguments_get(var, "o", &enc)) continue; eina_stringshare_replace(&v->partition_label, enc); venc = _e_fm_main_udisks_volume_find(enc); @@ -581,7 +581,7 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, else if (!strcmp(key, "PartitionSlave")) { char *partition_slave, buf[4096]; - if (!edbus_message_iter_arguments_get(var, "o", &partition_slave)) + if (!eldbus_message_iter_arguments_get(var, "o", &partition_slave)) continue; if ((!partition_slave) || (strlen(partition_slave) < sizeof("/org/freedesktop/UDisks/devices/"))) eina_stringshare_replace(&v->parent, partition_slave); @@ -688,7 +688,7 @@ _e_fm_main_udisks_vol_mount_timeout(E_Volume *v) v->guard = NULL; if (v->op) - edbus_pending_cancel(v->op); + eldbus_pending_cancel(v->op); v->op = NULL; v->optype = E_VOLUME_OP_TYPE_NONE; size = _e_fm_main_udisks_format_error_msg(&buf, v, @@ -737,7 +737,7 @@ _e_fm_main_udisks_vol_unmount_timeout(E_Volume *v) v->guard = NULL; if (v->op) - edbus_pending_cancel(v->op); + eldbus_pending_cancel(v->op); v->op = NULL; v->optype = E_VOLUME_OP_TYPE_NONE; size = _e_fm_main_udisks_format_error_msg(&buf, v, @@ -788,7 +788,7 @@ _e_fm_main_udisks_vol_eject_timeout(E_Volume *v) v->guard = NULL; if (v->op) - edbus_pending_cancel(v->op); + eldbus_pending_cancel(v->op); v->op = NULL; v->optype = E_VOLUME_OP_TYPE_NONE; size = _e_fm_main_udisks_format_error_msg(&buf, v, @@ -802,63 +802,63 @@ _e_fm_main_udisks_vol_eject_timeout(E_Volume *v) } static void -_volume_task_cb(void *data __UNUSED__, const EDBus_Message *msg __UNUSED__, - EDBus_Pending *pending __UNUSED__) +_volume_task_cb(void *data __UNUSED__, const Eldbus_Message *msg __UNUSED__, + Eldbus_Pending *pending __UNUSED__) { /** - * if edbus_proxy_send has callback == NULL it will return a NULL - * but we need a EDBus_Pending to be able to cancel it when timeout occurs + * if eldbus_proxy_send has callback == NULL it will return a NULL + * but we need a Eldbus_Pending to be able to cancel it when timeout occurs */ /* FIXME: this should not matter. If we don't have a callback, there's no - * reason to cancel it... cancelling has no effect other than saying edbus we + * reason to cancel it... cancelling has no effect other than saying eldbus we * are not interested in the return anymore. I.e.: don't bother to cancel it */ } -static EDBus_Pending * -_volume_umount(EDBus_Proxy *proxy) +static Eldbus_Pending * +_volume_umount(Eldbus_Proxy *proxy) { - EDBus_Message *msg; - EDBus_Message_Iter *array, *main_iter; + Eldbus_Message *msg; + Eldbus_Message_Iter *array, *main_iter; - msg = edbus_proxy_method_call_new(proxy, "FilesystemUnmount"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_arguments_append(main_iter, "as", &array); - edbus_message_iter_container_close(main_iter, array); + msg = eldbus_proxy_method_call_new(proxy, "FilesystemUnmount"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_arguments_append(main_iter, "as", &array); + eldbus_message_iter_container_close(main_iter, array); - return edbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); + return eldbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); } -static EDBus_Pending * -_volume_eject(EDBus_Proxy *proxy) +static Eldbus_Pending * +_volume_eject(Eldbus_Proxy *proxy) { - EDBus_Message *msg; - EDBus_Message_Iter *array, *main_iter; + Eldbus_Message *msg; + Eldbus_Message_Iter *array, *main_iter; - msg = edbus_proxy_method_call_new(proxy, "DriveEject"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_arguments_append(main_iter, "as", &array); - edbus_message_iter_container_close(main_iter, array); + msg = eldbus_proxy_method_call_new(proxy, "DriveEject"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_arguments_append(main_iter, "as", &array); + eldbus_message_iter_container_close(main_iter, array); - return edbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); + return eldbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); } -static EDBus_Pending * -_volume_mount(EDBus_Proxy *proxy, const char *fstype, Eina_List *opt) +static Eldbus_Pending * +_volume_mount(Eldbus_Proxy *proxy, const char *fstype, Eina_List *opt) { - EDBus_Message *msg; - EDBus_Message_Iter *array, *main_iter; + Eldbus_Message *msg; + Eldbus_Message_Iter *array, *main_iter; Eina_List *l; const char *opt_txt; - msg = edbus_proxy_method_call_new(proxy, "FilesystemMount"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_arguments_append(main_iter, "sas", fstype, &array); + msg = eldbus_proxy_method_call_new(proxy, "FilesystemMount"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_arguments_append(main_iter, "sas", fstype, &array); EINA_LIST_FOREACH(opt, l, opt_txt) - edbus_message_iter_basic_append(array, 's', opt_txt); - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_basic_append(array, 's', opt_txt); + eldbus_message_iter_container_close(main_iter, array); - return edbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); + return eldbus_proxy_send(proxy, msg, _volume_task_cb, NULL, -1); } static Eina_Bool @@ -907,7 +907,7 @@ _e_fm_main_udisks_volume_add(const char *path, Eina_Bool first_time) { E_Volume *v; - EDBus_Object *obj; + Eldbus_Object *obj; if (!path) return NULL; if (_volume_find_by_dbus_path(path)) return NULL; @@ -919,10 +919,10 @@ _e_fm_main_udisks_volume_add(const char *path, v->icon = NULL; v->first_time = first_time; _e_vols = eina_list_append(_e_vols, v); - obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); - v->proxy = edbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); - edbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); - edbus_proxy_signal_handler_add(v->proxy, "Changed", + obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); + v->proxy = eldbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); + eldbus_proxy_property_get_all(v->proxy, _e_fm_main_udisks_cb_vol_prop, v); + eldbus_proxy_signal_handler_add(v->proxy, "Changed", _e_fm_main_udisks_cb_prop_modified, v); v->guard = NULL; @@ -962,9 +962,9 @@ _volume_del(E_Volume *v) */ if (v->proxy) { - EDBus_Object *obj = edbus_proxy_object_get(v->proxy); - edbus_proxy_unref(v->proxy); - edbus_object_unref(obj); + Eldbus_Object *obj = eldbus_proxy_object_get(v->proxy); + eldbus_proxy_unref(v->proxy); + eldbus_object_unref(obj); } _e_vols = eina_list_remove(_e_vols, v); _e_fm_shared_device_volume_free(v); @@ -1084,11 +1084,11 @@ _e_fm_main_udisks_volume_mount(E_Volume *v) void _e_fm_main_udisks_init(void) { - edbus_init(); - _e_fm_main_udisks_conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); + eldbus_init(); + _e_fm_main_udisks_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); if (!_e_fm_main_udisks_conn) return; - edbus_name_start(_e_fm_main_udisks_conn, UDISKS_BUS, 0, + eldbus_name_start(_e_fm_main_udisks_conn, UDISKS_BUS, 0, _e_fm_main_udisks_name_start, NULL); } @@ -1097,21 +1097,21 @@ _e_fm_main_udisks_shutdown(void) { if (_e_fm_main_udisks_proxy) { - EDBus_Object *obj; - obj = edbus_proxy_object_get(_e_fm_main_udisks_proxy); - edbus_proxy_unref(_e_fm_main_udisks_proxy); - edbus_object_unref(obj); + Eldbus_Object *obj; + obj = eldbus_proxy_object_get(_e_fm_main_udisks_proxy); + eldbus_proxy_unref(_e_fm_main_udisks_proxy); + eldbus_object_unref(obj); } if (_e_fm_main_udisks_conn) - edbus_connection_unref(_e_fm_main_udisks_conn); - edbus_shutdown(); + eldbus_connection_unref(_e_fm_main_udisks_conn); + eldbus_shutdown(); } E_Storage * _e_fm_main_udisks_storage_add(const char *path) { E_Storage *s; - EDBus_Object *obj; + Eldbus_Object *obj; if (!path) return NULL; if (_storage_find_by_dbus_path(path)) return NULL; @@ -1121,9 +1121,9 @@ _e_fm_main_udisks_storage_add(const char *path) DBG("STORAGE+=%s", path); s->dbus_path = path; _e_stores = eina_list_append(_e_stores, s); - obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); - s->proxy = edbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); - edbus_proxy_property_get_all(s->proxy, _e_fm_main_udisks_cb_store_prop, s); + obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); + s->proxy = eldbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); + eldbus_proxy_property_get_all(s->proxy, _e_fm_main_udisks_cb_store_prop, s); return s; } @@ -1145,9 +1145,9 @@ _e_fm_main_udisks_storage_del(const char *path) _e_stores = eina_list_remove(_e_stores, s); if (s->proxy) { - EDBus_Object *obj = edbus_proxy_object_get(s->proxy); - edbus_proxy_unref(s->proxy); - edbus_object_unref(obj); + Eldbus_Object *obj = eldbus_proxy_object_get(s->proxy); + eldbus_proxy_unref(s->proxy); + eldbus_object_unref(obj); } _e_fm_shared_device_storage_free(s); } diff --git a/src/bin/e_fm_cmdline.c b/src/bin/e_fm_cmdline.c index 23810ab4b..11f498c4b 100644 --- a/src/bin/e_fm_cmdline.c +++ b/src/bin/e_fm_cmdline.c @@ -4,16 +4,16 @@ #include "e.h" -static EDBus_Connection *conn = NULL; +static Eldbus_Connection *conn = NULL; static int retval = EXIT_SUCCESS; static int pending = 0; static void -fm_open_reply(void *data __UNUSED__, const EDBus_Message *msg, - EDBus_Pending *dbus_pending __UNUSED__) +fm_open_reply(void *data __UNUSED__, const Eldbus_Message *msg, + Eldbus_Pending *dbus_pending __UNUSED__) { const char *name, *txt; - if (edbus_message_error_get(msg, &name, &txt)) + if (eldbus_message_error_get(msg, &name, &txt)) { retval = EXIT_FAILURE; ERR("%s: %s", name, txt); @@ -33,7 +33,7 @@ fm_error_quit_last(void *data __UNUSED__) static void fm_open(const char *path) { - EDBus_Message *msg; + Eldbus_Message *msg; const char *method; char *p; @@ -87,7 +87,7 @@ fm_open(const char *path) else method = "OpenFile"; - msg = edbus_message_method_call_new("org.enlightenment.FileManager", + msg = eldbus_message_method_call_new("org.enlightenment.FileManager", "/org/enlightenment/FileManager", "org.enlightenment.FileManager", method); @@ -98,13 +98,13 @@ fm_open(const char *path) free(p); return; } - edbus_message_arguments_append(msg, "s", p); + eldbus_message_arguments_append(msg, "s", p); free(p); - if (!edbus_connection_send(conn, msg, fm_open_reply, NULL, -1)) + if (!eldbus_connection_send(conn, msg, fm_open_reply, NULL, -1)) { ERR("Could not send DBus Message"); - edbus_message_unref(msg); + eldbus_message_unref(msg); ecore_idler_add(fm_error_quit_last, NULL); } else @@ -152,9 +152,9 @@ main(int argc, char *argv[]) ecore_init(); ecore_file_init(); - edbus_init(); + eldbus_init(); - conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); if (!conn) { ERR("Could not DBus SESSION bus."); @@ -172,9 +172,9 @@ main(int argc, char *argv[]) } ecore_main_loop_begin(); - edbus_connection_unref(conn); + eldbus_connection_unref(conn); end: - edbus_shutdown(); + eldbus_shutdown(); ecore_file_shutdown(); ecore_shutdown(); return retval; diff --git a/src/bin/e_fm_shared_types.h.in b/src/bin/e_fm_shared_types.h.in index 2ae5f2a7f..d041b9ad7 100644 --- a/src/bin/e_fm_shared_types.h.in +++ b/src/bin/e_fm_shared_types.h.in @@ -9,7 +9,7 @@ # include #endif #if @DBUS_MOUNT_CONFIG@ -# include +# include #endif # define E_DEVICE_TYPE_STORAGE 1 @@ -71,7 +71,7 @@ struct _E_Storage Eina_Bool validated : 1; Eina_Bool trackable : 1; #if @DBUS_MOUNT_CONFIG@ - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; const char *dbus_path; #endif #if @EEZE_MOUNT_CONFIG@ @@ -111,8 +111,8 @@ struct _E_Volume Eina_Bool unlocked; #if @DBUS_MOUNT_CONFIG@ - EDBus_Pending *op; - EDBus_Proxy *proxy; + Eldbus_Pending *op; + Eldbus_Proxy *proxy; const char *dbus_path; #endif #if @EEZE_MOUNT_CONFIG@ diff --git a/src/bin/e_msgbus.c b/src/bin/e_msgbus.c index 819a5f6c5..722724a44 100644 --- a/src/bin/e_msgbus.c +++ b/src/bin/e_msgbus.c @@ -1,39 +1,39 @@ #include "e.h" /* local subsystem functions */ -static void _e_msgbus_request_name_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending); +static void _e_msgbus_request_name_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending); -static EDBus_Message *_e_msgbus_core_restart_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_core_shutdown_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); +static Eldbus_Message *_e_msgbus_core_restart_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_core_shutdown_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); -static EDBus_Message *_e_msgbus_module_load_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_module_list_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); +static Eldbus_Message *_e_msgbus_module_load_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_module_unload_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_module_enable_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_module_disable_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_module_list_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); -static EDBus_Message *_e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_profile_get_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_profile_list_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_profile_add_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); -static EDBus_Message *_e_msgbus_profile_delete_cb(const EDBus_Service_Interface *iface, - const EDBus_Message *msg); +static Eldbus_Message *_e_msgbus_profile_set_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_profile_get_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_profile_list_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_profile_add_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); +static Eldbus_Message *_e_msgbus_profile_delete_cb(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg); #define E_MSGBUS_WIN_ACTION_CB_PROTO(NAME) \ - static EDBus_Message * _e_msgbus_window_##NAME##_cb(const EDBus_Service_Interface * iface, \ - const EDBus_Message * msg) + static Eldbus_Message * _e_msgbus_window_##NAME##_cb(const Eldbus_Service_Interface * iface, \ + const Eldbus_Message * msg) E_MSGBUS_WIN_ACTION_CB_PROTO(list); E_MSGBUS_WIN_ACTION_CB_PROTO(close); @@ -47,64 +47,64 @@ E_MSGBUS_WIN_ACTION_CB_PROTO(unmaximize); /* local subsystem globals */ static E_Msgbus_Data *_e_msgbus_data = NULL; -static const EDBus_Method core_methods[] = { +static const Eldbus_Method core_methods[] = { { "Restart", NULL, NULL, _e_msgbus_core_restart_cb }, { "Shutdown", NULL, NULL, _e_msgbus_core_shutdown_cb }, { } }; -static const EDBus_Method module_methods[] = { - { "Load", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_load_cb }, - { "Unload", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_unload_cb }, - { "Enable", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_enable_cb }, - { "Disable", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_disable_cb }, - { "List", NULL, EDBUS_ARGS({"a(si)", "modules"}), +static const Eldbus_Method module_methods[] = { + { "Load", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_load_cb }, + { "Unload", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_unload_cb }, + { "Enable", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_enable_cb }, + { "Disable", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_disable_cb }, + { "List", NULL, ELDBUS_ARGS({"a(si)", "modules"}), _e_msgbus_module_list_cb }, { } }; -static const EDBus_Method profile_methods[] = { - { "Set", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_set_cb }, - { "Get", NULL, EDBUS_ARGS({"s", "profile"}), _e_msgbus_profile_get_cb }, - { "List", NULL, EDBUS_ARGS({"as", "array_profiles"}), +static const Eldbus_Method profile_methods[] = { + { "Set", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_set_cb }, + { "Get", NULL, ELDBUS_ARGS({"s", "profile"}), _e_msgbus_profile_get_cb }, + { "List", NULL, ELDBUS_ARGS({"as", "array_profiles"}), _e_msgbus_profile_list_cb }, - { "Add", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_add_cb }, - { "Delete", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_delete_cb }, + { "Add", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_add_cb }, + { "Delete", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_delete_cb }, { } }; -static const EDBus_Method window_methods[] = { - { "List", NULL, EDBUS_ARGS({"a(si)", "array_of_window"}), +static const Eldbus_Method window_methods[] = { + { "List", NULL, ELDBUS_ARGS({"a(si)", "array_of_window"}), _e_msgbus_window_list_cb }, - { "Close", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_close_cb }, - { "Kill", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_kill_cb }, - { "Focus", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_focus_cb }, - { "Iconify", EDBUS_ARGS({"i", "window_id"}), NULL, + { "Close", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_close_cb }, + { "Kill", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_kill_cb }, + { "Focus", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_focus_cb }, + { "Iconify", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_iconify_cb }, - { "Uniconify", EDBUS_ARGS({"i", "window_id"}), NULL, + { "Uniconify", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_uniconify_cb }, - { "Maximize", EDBUS_ARGS({"i", "window_id"}), NULL, + { "Maximize", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_maximize_cb }, - { "Unmaximize", EDBUS_ARGS({"i", "window_id"}), NULL, + { "Unmaximize", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_unmaximize_cb }, { } }; #define PATH "/org/enlightenment/wm/RemoteObject" -static const EDBus_Service_Interface_Desc core_desc = { +static const Eldbus_Service_Interface_Desc core_desc = { "org.enlightenment.wm.Core", core_methods }; -static const EDBus_Service_Interface_Desc module_desc = { +static const Eldbus_Service_Interface_Desc module_desc = { "org.enlightenment.wm.Module", module_methods }; -static const EDBus_Service_Interface_Desc profile_desc = { +static const Eldbus_Service_Interface_Desc profile_desc = { "org.enlightenment.wm.Profile", profile_methods }; -static const EDBus_Service_Interface_Desc window_desc = { +static const Eldbus_Service_Interface_Desc window_desc = { "org.enlightenment.wm.Window", window_methods }; @@ -114,21 +114,21 @@ e_msgbus_init(void) { _e_msgbus_data = E_NEW(E_Msgbus_Data, 1); - edbus_init(); + eldbus_init(); - _e_msgbus_data->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + _e_msgbus_data->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); if (!_e_msgbus_data->conn) { - WRN("Cannot get EDBUS_CONNECTION_TYPE_SESSION"); + WRN("Cannot get ELDBUS_CONNECTION_TYPE_SESSION"); return 0; } - _e_msgbus_data->iface = edbus_service_interface_register(_e_msgbus_data->conn, + _e_msgbus_data->iface = eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &core_desc); - edbus_service_interface_register(_e_msgbus_data->conn, PATH, &module_desc); - edbus_service_interface_register(_e_msgbus_data->conn, PATH, &profile_desc); - edbus_service_interface_register(_e_msgbus_data->conn, PATH, &window_desc); - edbus_name_request(_e_msgbus_data->conn, "org.enlightenment.wm.service", + eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &module_desc); + eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &profile_desc); + eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &window_desc); + eldbus_name_request(_e_msgbus_data->conn, "org.enlightenment.wm.service", 0, _e_msgbus_request_name_cb, NULL); return 1; } @@ -137,76 +137,76 @@ EINTERN int e_msgbus_shutdown(void) { if (_e_msgbus_data->iface) - edbus_service_object_unregister(_e_msgbus_data->iface); + eldbus_service_object_unregister(_e_msgbus_data->iface); if (_e_msgbus_data->conn) { - edbus_name_release(_e_msgbus_data->conn, + eldbus_name_release(_e_msgbus_data->conn, "org.enlightenment.wm.service", NULL, NULL); - edbus_connection_unref(_e_msgbus_data->conn); + eldbus_connection_unref(_e_msgbus_data->conn); } - edbus_shutdown(); + eldbus_shutdown(); E_FREE(_e_msgbus_data); _e_msgbus_data = NULL; return 1; } -EAPI EDBus_Service_Interface * -e_msgbus_interface_attach(const EDBus_Service_Interface_Desc *desc) +EAPI Eldbus_Service_Interface * +e_msgbus_interface_attach(const Eldbus_Service_Interface_Desc *desc) { if (!_e_msgbus_data->iface) return NULL; - return edbus_service_interface_register(_e_msgbus_data->conn, PATH, desc); + return eldbus_service_interface_register(_e_msgbus_data->conn, PATH, desc); } static void -_e_msgbus_request_name_cb(void *data __UNUSED__, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_e_msgbus_request_name_cb(void *data __UNUSED__, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { unsigned int flag; - if (edbus_message_error_get(msg, NULL, NULL)) + if (eldbus_message_error_get(msg, NULL, NULL)) { ERR("Could not request bus name"); return; } - if (!edbus_message_arguments_get(msg, "u", &flag)) + if (!eldbus_message_arguments_get(msg, "u", &flag)) { ERR("Could not get arguments on on_name_request"); return; } - if (!(flag & EDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER)) + if (!(flag & ELDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER)) ERR("Name already in use\n"); } /* Core Handlers */ -static EDBus_Message * -_e_msgbus_core_restart_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_core_restart_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { e_sys_action_do(E_SYS_RESTART, NULL); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -_e_msgbus_core_shutdown_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_core_shutdown_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { e_sys_action_do(E_SYS_EXIT, NULL); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } /* Modules Handlers */ -static EDBus_Message * -_e_msgbus_module_load_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_module_load_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *module; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &module)) + if (!eldbus_message_arguments_get(msg, "s", &module)) return reply; if (!e_module_find(module)) @@ -218,15 +218,15 @@ _e_msgbus_module_load_cb(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -_e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_module_unload_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *module; E_Module *m; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &module)) + if (!eldbus_message_arguments_get(msg, "s", &module)) return reply; if ((m = e_module_find(module))) @@ -239,15 +239,15 @@ _e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -_e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_module_enable_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *module; E_Module *m; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &module)) + if (!eldbus_message_arguments_get(msg, "s", &module)) return reply; if ((m = e_module_find(module))) @@ -259,15 +259,15 @@ _e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -_e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_module_disable_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *module; E_Module *m; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &module)) + if (!eldbus_message_arguments_get(msg, "s", &module)) return reply; if ((m = e_module_find(module))) @@ -279,50 +279,50 @@ _e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -_e_msgbus_module_list_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_module_list_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { Eina_List *l; E_Module *mod; - EDBus_Message *reply = edbus_message_method_return_new(msg); - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message *reply = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *main_iter, *array; EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL); - main_iter = edbus_message_iter_get(reply); + main_iter = eldbus_message_iter_get(reply); EINA_SAFETY_ON_NULL_RETURN_VAL(main_iter, reply); - edbus_message_iter_arguments_append(main_iter, "a(si)", &array); + eldbus_message_iter_arguments_append(main_iter, "a(si)", &array); EINA_SAFETY_ON_NULL_RETURN_VAL(array, reply); EINA_LIST_FOREACH(e_module_list(), l, mod) { - EDBus_Message_Iter *s; + Eldbus_Message_Iter *s; const char *name; int enabled; name = mod->name; enabled = mod->enabled; - edbus_message_iter_arguments_append(array, "(si)", &s); + eldbus_message_iter_arguments_append(array, "(si)", &s); if (!s) continue; - edbus_message_iter_arguments_append(s, "si", name, enabled); - edbus_message_iter_container_close(array, s); + eldbus_message_iter_arguments_append(s, "si", name, enabled); + eldbus_message_iter_container_close(array, s); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } /* Profile Handlers */ -static EDBus_Message * -_e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_profile_set_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *profile; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &profile)) + if (!eldbus_message_arguments_get(msg, "s", &profile)) return reply; e_config_save_flush(); @@ -334,129 +334,129 @@ _e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -_e_msgbus_profile_get_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_profile_get_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); const char *profile; EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL); profile = e_config_profile_get(); - edbus_message_arguments_append(reply, "s", profile); + eldbus_message_arguments_append(reply, "s", profile); return reply; } -static EDBus_Message * -_e_msgbus_profile_list_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_profile_list_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { Eina_List *l; char *name; - EDBus_Message *reply; - EDBus_Message_Iter *array, *main_iter; + Eldbus_Message *reply; + Eldbus_Message_Iter *array, *main_iter; - reply = edbus_message_method_return_new(msg); + reply = eldbus_message_method_return_new(msg); EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL); - main_iter = edbus_message_iter_get(reply); + main_iter = eldbus_message_iter_get(reply); EINA_SAFETY_ON_FALSE_RETURN_VAL(main_iter, reply); - edbus_message_iter_arguments_append(main_iter, "as", &array); + eldbus_message_iter_arguments_append(main_iter, "as", &array); EINA_SAFETY_ON_FALSE_RETURN_VAL(array, reply); l = e_config_profile_list(); EINA_LIST_FREE(l, name) { - edbus_message_iter_basic_append(array, 's', name); + eldbus_message_iter_basic_append(array, 's', name); free(name); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } -static EDBus_Message * -_e_msgbus_profile_add_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_profile_add_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *profile; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "s", &profile)) + if (!eldbus_message_arguments_get(msg, "s", &profile)) return reply; e_config_profile_add(profile); return reply; } -static EDBus_Message * -_e_msgbus_profile_delete_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_profile_delete_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { char *profile; - if (!edbus_message_arguments_get(msg, "s", &profile)) - return edbus_message_method_return_new(msg); + if (!eldbus_message_arguments_get(msg, "s", &profile)) + return eldbus_message_method_return_new(msg); if (!strcmp(e_config_profile_get(), profile)) - return edbus_message_error_new(msg, + return eldbus_message_error_new(msg, "org.enlightenment.DBus.InvalidArgument", "Can't delete active profile"); e_config_profile_del(profile); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } /* Window handlers */ -static EDBus_Message * -_e_msgbus_window_list_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_msgbus_window_list_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { Eina_List *l; E_Border *bd; - EDBus_Message *reply; - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message *reply; + Eldbus_Message_Iter *main_iter, *array; - reply = edbus_message_method_return_new(msg); + reply = eldbus_message_method_return_new(msg); EINA_SAFETY_ON_FALSE_RETURN_VAL(reply, NULL); - main_iter = edbus_message_iter_get(reply); + main_iter = eldbus_message_iter_get(reply); EINA_SAFETY_ON_FALSE_RETURN_VAL(main_iter, reply); - edbus_message_iter_arguments_append(main_iter, "a(si)", &array); + eldbus_message_iter_arguments_append(main_iter, "a(si)", &array); EINA_SAFETY_ON_FALSE_RETURN_VAL(array, reply); EINA_LIST_FOREACH(e_border_client_list(), l, bd) { - EDBus_Message_Iter *s; + Eldbus_Message_Iter *s; - edbus_message_iter_arguments_append(array, "(si)", &s); + eldbus_message_iter_arguments_append(array, "(si)", &s); if (!s) continue; - edbus_message_iter_arguments_append(s, "si", bd->client.icccm.name, + eldbus_message_iter_arguments_append(s, "si", bd->client.icccm.name, bd->client.win); - edbus_message_iter_container_close(array, s); + eldbus_message_iter_container_close(array, s); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } #define E_MSGBUS_WIN_ACTION_CB_BEGIN(NAME) \ - static EDBus_Message * \ - _e_msgbus_window_##NAME##_cb(const EDBus_Service_Interface * iface __UNUSED__, \ - const EDBus_Message * msg) \ + static Eldbus_Message * \ + _e_msgbus_window_##NAME##_cb(const Eldbus_Service_Interface * iface __UNUSED__, \ + const Eldbus_Message * msg) \ { \ E_Border *bd; \ int xwin; \ \ - if (!edbus_message_arguments_get(msg, "i", &xwin)) \ - return edbus_message_method_return_new(msg); \ + if (!eldbus_message_arguments_get(msg, "i", &xwin)) \ + return eldbus_message_method_return_new(msg); \ bd = e_border_find_by_client_window(xwin); \ if (bd) \ { #define E_MSGBUS_WIN_ACTION_CB_END \ } \ \ - return edbus_message_method_return_new(msg); \ + return eldbus_message_method_return_new(msg); \ } E_MSGBUS_WIN_ACTION_CB_BEGIN(close) diff --git a/src/bin/e_msgbus.h b/src/bin/e_msgbus.h index 4fe59481a..ae4857217 100644 --- a/src/bin/e_msgbus.h +++ b/src/bin/e_msgbus.h @@ -6,17 +6,17 @@ typedef struct _E_Msgbus_Data E_Msgbus_Data; #ifndef E_MSGBUS_H #define E_MSGBUS_H -/* This is the dbus subsystem, but edbus namespace is taken by edbus */ +/* This is the dbus subsystem, but eldbus namespace is taken by eldbus */ struct _E_Msgbus_Data { - EDBus_Connection *conn; - EDBus_Service_Interface *iface; + Eldbus_Connection *conn; + Eldbus_Service_Interface *iface; }; EINTERN int e_msgbus_init(void); EINTERN int e_msgbus_shutdown(void); -EAPI EDBus_Service_Interface *e_msgbus_interface_attach(const EDBus_Service_Interface_Desc *desc); +EAPI Eldbus_Service_Interface *e_msgbus_interface_attach(const Eldbus_Service_Interface_Desc *desc); #endif #endif diff --git a/src/bin/e_notification.c b/src/bin/e_notification.c index acc3dd3c1..756837f1a 100644 --- a/src/bin/e_notification.c +++ b/src/bin/e_notification.c @@ -2,8 +2,8 @@ typedef struct _Notification_Data { - EDBus_Connection *conn; - EDBus_Service_Interface *iface; + Eldbus_Connection *conn; + Eldbus_Service_Interface *iface; E_Notification_Notify_Cb notify_cb; E_Notification_Close_Cb close_cb; void *data; @@ -13,22 +13,22 @@ typedef struct _Notification_Data static Notification_Data *n_data = NULL; static void -hints_dict_iter(void *data, const void *key, EDBus_Message_Iter *var) +hints_dict_iter(void *data, const void *key, Eldbus_Message_Iter *var) { E_Notification_Notify *n = data; if (!strcmp(key, "image-data") || !strcmp(key, "image_data")) { - EDBus_Message_Iter *st, *data_iter; + Eldbus_Message_Iter *st, *data_iter; int w, h, r, bits, channels; Eina_Bool alpha; unsigned char *raw_data; - if (!edbus_message_iter_arguments_get(var, "(iiibiiay)", &st)) + if (!eldbus_message_iter_arguments_get(var, "(iiibiiay)", &st)) return; - if (!edbus_message_iter_arguments_get(st, "iiibiiay", &w, &h, &r, + if (!eldbus_message_iter_arguments_get(st, "iiibiiay", &w, &h, &r, &alpha, &bits, &channels, &data_iter)) return; - edbus_message_iter_fixed_array_get(data_iter, 'y', &raw_data, + eldbus_message_iter_fixed_array_get(data_iter, 'y', &raw_data, &n->icon.raw.data_size); n->icon.raw.width = w; n->icon.raw.height = h; @@ -43,23 +43,23 @@ hints_dict_iter(void *data, const void *key, EDBus_Message_Iter *var) else if (!strcmp(key, "urgency")) { unsigned char urgency; - edbus_message_iter_arguments_get(var, "y", &urgency); + eldbus_message_iter_arguments_get(var, "y", &urgency); if (urgency < 3) n->urgency = urgency; } else if (!strcmp(key, "image-path") || !strcmp(key, "image_path")) { - edbus_message_iter_arguments_get(var, "s", &n->icon.icon_path); + eldbus_message_iter_arguments_get(var, "s", &n->icon.icon_path); n->icon.icon_path = eina_stringshare_add(n->icon.icon_path); } } -static EDBus_Message * -notify_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) +static Eldbus_Message * +notify_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { E_Notification_Notify *n; - EDBus_Message_Iter *actions_iter, *hints_iter; - EDBus_Message *reply; + Eldbus_Message_Iter *actions_iter, *hints_iter; + Eldbus_Message *reply; if (!n_data->notify_cb) return NULL; @@ -67,7 +67,7 @@ notify_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message n = calloc(1, sizeof(E_Notification_Notify)); EINA_SAFETY_ON_NULL_RETURN_VAL(n, NULL); - if (!edbus_message_arguments_get(msg, "susssasa{sv}i", &n->app_name, + if (!eldbus_message_arguments_get(msg, "susssasa{sv}i", &n->app_name, &n->replaces_id, &n->icon.icon, &n->sumary, &n->body, &actions_iter, &hints_iter, &n->timeout)) @@ -76,66 +76,66 @@ notify_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message free(n); return NULL; } - edbus_message_iter_dict_iterate(hints_iter, "sv", hints_dict_iter, n); + eldbus_message_iter_dict_iterate(hints_iter, "sv", hints_dict_iter, n); n->app_name = eina_stringshare_add(n->app_name); n->icon.icon = eina_stringshare_add(n->icon.icon); n->sumary = eina_stringshare_add(n->sumary); n->body = eina_stringshare_add(n->body); n->id = n_data->notify_cb(n_data->data, n); - reply = edbus_message_method_return_new(msg); - edbus_message_arguments_append(reply, "u", n->id); + reply = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(reply, "u", n->id); return reply; } -static EDBus_Message * -close_notification_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) +static Eldbus_Message * +close_notification_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { unsigned id; - if (!edbus_message_arguments_get(msg, "u", &id)) + if (!eldbus_message_arguments_get(msg, "u", &id)) return NULL; if (n_data->close_cb) n_data->close_cb(n_data->data, id); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -capabilities_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) +static Eldbus_Message * +capabilities_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); int i; - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message_Iter *main_iter, *array; - main_iter = edbus_message_iter_get(reply); - edbus_message_iter_arguments_append(main_iter, "as", &array); + main_iter = eldbus_message_iter_get(reply); + eldbus_message_iter_arguments_append(main_iter, "as", &array); for (i = 0; n_data->server_info->capabilities[i]; i++) - edbus_message_iter_arguments_append(array, "s", + eldbus_message_iter_arguments_append(array, "s", n_data->server_info->capabilities[i]); - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } -static EDBus_Message * -server_info_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) +static Eldbus_Message * +server_info_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); - edbus_message_arguments_append(reply, "ssss", n_data->server_info->name, + Eldbus_Message *reply = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(reply, "ssss", n_data->server_info->name, n_data->server_info->vendor, n_data->server_info->version, n_data->server_info->spec_version); return reply; } -static const EDBus_Method methods[] = { +static const Eldbus_Method methods[] = { { "Notify", - EDBUS_ARGS({"s", "app_name"}, {"u", "replaces_id"}, {"s", "app_icon"}, {"s", "summary"}, {"s", "body"}, {"as", "actions"}, {"a{sv}", "hints"}, {"i", "expire_timeout"}), - EDBUS_ARGS({"u", "id"}), notify_cb }, - { "CloseNotification", EDBUS_ARGS({"u", "id"}), NULL, close_notification_cb }, - { "GetCapabilities", NULL, EDBUS_ARGS({"as", "capabilities"}), + ELDBUS_ARGS({"s", "app_name"}, {"u", "replaces_id"}, {"s", "app_icon"}, {"s", "summary"}, {"s", "body"}, {"as", "actions"}, {"a{sv}", "hints"}, {"i", "expire_timeout"}), + ELDBUS_ARGS({"u", "id"}), notify_cb }, + { "CloseNotification", ELDBUS_ARGS({"u", "id"}), NULL, close_notification_cb }, + { "GetCapabilities", NULL, ELDBUS_ARGS({"as", "capabilities"}), capabilities_cb }, { "GetServerInformation", NULL, - EDBUS_ARGS({"s", "name"}, {"s", "vendor"}, {"s", "version"}, {"s", "spec_version"}), + ELDBUS_ARGS({"s", "name"}, {"s", "vendor"}, {"s", "version"}, {"s", "spec_version"}), server_info_cb }, { } }; @@ -146,11 +146,11 @@ enum SIGNAL_ACTION_INVOKED, }; -static const EDBus_Signal signals[] = { +static const Eldbus_Signal signals[] = { [SIGNAL_NOTIFICATION_CLOSED] = - { "NotificationClosed", EDBUS_ARGS({"u", "id"}, {"u", "reason"}) }, + { "NotificationClosed", ELDBUS_ARGS({"u", "id"}, {"u", "reason"}) }, [SIGNAL_ACTION_INVOKED] = - { "ActionInvoked", EDBUS_ARGS({"u", "id"}, {"s", "action_key"}) }, + { "ActionInvoked", ELDBUS_ARGS({"u", "id"}, {"s", "action_key"}) }, { } }; @@ -158,7 +158,7 @@ static const EDBus_Signal signals[] = { #define BUS "org.freedesktop.Notifications" #define INTERFACE "org.freedesktop.Notifications" -static const EDBus_Service_Interface_Desc desc = { +static const Eldbus_Service_Interface_Desc desc = { INTERFACE, methods, signals, NULL, NULL, NULL }; @@ -171,15 +171,15 @@ e_notification_server_register(const E_Notification_Server_Info *server_info, E_ n_data = calloc(1, sizeof(Notification_Data)); EINA_SAFETY_ON_NULL_RETURN_VAL(n_data, EINA_FALSE); - edbus_init(); - n_data->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); - n_data->iface = edbus_service_interface_register(n_data->conn, PATH, &desc); + eldbus_init(); + n_data->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); + n_data->iface = eldbus_service_interface_register(n_data->conn, PATH, &desc); n_data->notify_cb = n_cb; n_data->close_cb = close_cb; n_data->data = (void *)data; n_data->server_info = server_info; - edbus_name_request(n_data->conn, BUS, - EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); + eldbus_name_request(n_data->conn, BUS, + ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); return EINA_TRUE; } @@ -188,9 +188,9 @@ EAPI void e_notification_server_unregister(void) { EINA_SAFETY_ON_NULL_RETURN(n_data); - edbus_service_interface_unregister(n_data->iface); - edbus_connection_unref(n_data->conn); - edbus_shutdown(); + eldbus_service_interface_unregister(n_data->iface); + eldbus_connection_unref(n_data->conn); + eldbus_shutdown(); free(n_data); n_data = NULL; } @@ -216,7 +216,7 @@ e_notification_notify_close(E_Notification_Notify *notify, E_Notification_Notify EINA_SAFETY_ON_NULL_RETURN(n_data); EINA_SAFETY_ON_NULL_RETURN(notify); EINA_SAFETY_ON_FALSE_RETURN(reason <= E_NOTIFICATION_NOTIFY_CLOSED_REASON_UNDEFINED); - edbus_service_signal_emit(n_data->iface, SIGNAL_NOTIFICATION_CLOSED, + eldbus_service_signal_emit(n_data->iface, SIGNAL_NOTIFICATION_CLOSED, notify->id, reason); } @@ -277,40 +277,40 @@ error: /* client API */ static void -client_notify_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +client_notify_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { unsigned id = 0; - E_Notification_Client_Send_Cb cb = edbus_pending_data_del(pending, "cb"); - EDBus_Connection *conn = edbus_pending_data_del(pending, "conn"); - if (edbus_message_error_get(msg, NULL, NULL)) + E_Notification_Client_Send_Cb cb = eldbus_pending_data_del(pending, "cb"); + Eldbus_Connection *conn = eldbus_pending_data_del(pending, "conn"); + if (eldbus_message_error_get(msg, NULL, NULL)) goto end; - if (!edbus_message_arguments_get(msg, "u", &id)) + if (!eldbus_message_arguments_get(msg, "u", &id)) goto end; end: cb(data, id); - edbus_connection_unref(conn); - edbus_shutdown(); + eldbus_connection_unref(conn); + eldbus_shutdown(); } static Eina_Bool notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Client_Send_Cb cb, const void *data) { - EDBus_Connection *conn; - EDBus_Message *msg; - EDBus_Message_Iter *main_iter, *actions, *hints; - EDBus_Message_Iter *entry, *var; - EDBus_Pending *p; + Eldbus_Connection *conn; + Eldbus_Message *msg; + Eldbus_Message_Iter *main_iter, *actions, *hints; + Eldbus_Message_Iter *entry, *var; + Eldbus_Pending *p; EINA_SAFETY_ON_NULL_RETURN_VAL(notify, EINA_FALSE); - edbus_init(); - conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + eldbus_init(); + conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); EINA_SAFETY_ON_NULL_RETURN_VAL(conn, EINA_FALSE); - msg = edbus_message_method_call_new(BUS, PATH, INTERFACE, "Notify"); + msg = eldbus_message_method_call_new(BUS, PATH, INTERFACE, "Notify"); EINA_SAFETY_ON_NULL_RETURN_VAL(msg, EINA_FALSE); //build message - main_iter = edbus_message_iter_get(msg); - if (!edbus_message_iter_arguments_append(main_iter, "susssas", + main_iter = eldbus_message_iter_get(msg); + if (!eldbus_message_iter_arguments_append(main_iter, "susssas", notify->app_name ? : "", notify->replaces_id, notify->icon.icon ? : "", @@ -318,19 +318,19 @@ notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Clie notify->body ? : "", &actions)) goto error; - edbus_message_iter_container_close(main_iter, actions); - if (!edbus_message_iter_arguments_append(main_iter, "a{sv}", &hints)) + eldbus_message_iter_container_close(main_iter, actions); + if (!eldbus_message_iter_arguments_append(main_iter, "a{sv}", &hints)) goto error; if (notify->icon.raw.data) { - EDBus_Message_Iter *st, *data_iter; + Eldbus_Message_Iter *st, *data_iter; int i; - edbus_message_iter_arguments_append(hints, "{sv}", &entry); - edbus_message_iter_arguments_append(entry, "s", "image-data"); - var = edbus_message_iter_container_new(entry, 'v', "(iiibiiay)"); - edbus_message_iter_arguments_append(var, "(iiibiiay)", &st); - edbus_message_iter_arguments_append(st, "iiibiiay", + eldbus_message_iter_arguments_append(hints, "{sv}", &entry); + eldbus_message_iter_arguments_append(entry, "s", "image-data"); + var = eldbus_message_iter_container_new(entry, 'v', "(iiibiiay)"); + eldbus_message_iter_arguments_append(var, "(iiibiiay)", &st); + eldbus_message_iter_arguments_append(st, "iiibiiay", notify->icon.raw.width, notify->icon.raw.height, notify->icon.raw.rowstride, @@ -339,42 +339,42 @@ notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Clie notify->icon.raw.channels, &data_iter); for (i = 0; i < notify->icon.raw.data_size; i++) - edbus_message_iter_basic_append(data_iter, 'y', notify->icon.raw.data[i]); - edbus_message_iter_container_close(st, data_iter); - edbus_message_iter_container_close(var, st); - edbus_message_iter_container_close(entry, var); - edbus_message_iter_container_close(hints, entry); + eldbus_message_iter_basic_append(data_iter, 'y', notify->icon.raw.data[i]); + eldbus_message_iter_container_close(st, data_iter); + eldbus_message_iter_container_close(var, st); + eldbus_message_iter_container_close(entry, var); + eldbus_message_iter_container_close(hints, entry); } if (notify->icon.icon_path) { - edbus_message_iter_arguments_append(hints, "{sv}", &entry); - edbus_message_iter_arguments_append(entry, "s", "image-path"); - var = edbus_message_iter_container_new(entry, 'v', "s"); - edbus_message_iter_arguments_append(var, "s", notify->icon.icon_path); - edbus_message_iter_container_close(entry, var); - edbus_message_iter_container_close(hints, entry); + eldbus_message_iter_arguments_append(hints, "{sv}", &entry); + eldbus_message_iter_arguments_append(entry, "s", "image-path"); + var = eldbus_message_iter_container_new(entry, 'v', "s"); + eldbus_message_iter_arguments_append(var, "s", notify->icon.icon_path); + eldbus_message_iter_container_close(entry, var); + eldbus_message_iter_container_close(hints, entry); } - edbus_message_iter_arguments_append(hints, "{sv}", &entry); - edbus_message_iter_arguments_append(entry, "s", "urgency"); - var = edbus_message_iter_container_new(entry, 'v', "y"); - edbus_message_iter_arguments_append(var, "y", notify->urgency); - edbus_message_iter_container_close(entry, var); - edbus_message_iter_container_close(hints, entry); + eldbus_message_iter_arguments_append(hints, "{sv}", &entry); + eldbus_message_iter_arguments_append(entry, "s", "urgency"); + var = eldbus_message_iter_container_new(entry, 'v', "y"); + eldbus_message_iter_arguments_append(var, "y", notify->urgency); + eldbus_message_iter_container_close(entry, var); + eldbus_message_iter_container_close(hints, entry); - edbus_message_iter_container_close(main_iter, hints); + eldbus_message_iter_container_close(main_iter, hints); - edbus_message_iter_arguments_append(main_iter, "i", notify->timeout); + eldbus_message_iter_arguments_append(main_iter, "i", notify->timeout); - p = edbus_connection_send(conn, msg, client_notify_cb, data, 5000); + p = eldbus_connection_send(conn, msg, client_notify_cb, data, 5000); EINA_SAFETY_ON_NULL_GOTO(p, error); - edbus_pending_data_set(p, "cb", cb); - edbus_pending_data_set(p, "conn", conn); + eldbus_pending_data_set(p, "cb", cb); + eldbus_pending_data_set(p, "conn", conn); return EINA_TRUE; error: - edbus_message_unref(msg); + eldbus_message_unref(msg); return EINA_FALSE; } diff --git a/src/bin/e_notification.h b/src/bin/e_notification.h index 291c2114e..554ecdd13 100644 --- a/src/bin/e_notification.h +++ b/src/bin/e_notification.h @@ -1,7 +1,7 @@ #ifndef _E_NOTIFICATION_H #define _E_NOTIFICATION_H -#include +#include #include typedef enum _E_Notification_Notify_Urgency diff --git a/src/modules/Makefile_music_control.am b/src/modules/Makefile_music_control.am index 51685f813..552b5bd6d 100644 --- a/src/modules/Makefile_music_control.am +++ b/src/modules/Makefile_music_control.am @@ -14,8 +14,8 @@ music_control_module_la_SOURCES = music-control/e_mod_main.h \ music-control/e_mod_main.c \ music-control/private.h \ music-control/ui.c \ - music-control/gen/edbus_utils.h \ - music-control/gen/edbus_media_player2_player.c \ - music-control/gen/edbus_media_player2_player.h \ - music-control/gen/edbus_mpris_media_player2.c \ - music-control/gen/edbus_mpris_media_player2.h + music-control/gen/eldbus_utils.h \ + music-control/gen/eldbus_media_player2_player.c \ + music-control/gen/eldbus_media_player2_player.h \ + music-control/gen/eldbus_mpris_media_player2.c \ + music-control/gen/eldbus_mpris_media_player2.h diff --git a/src/modules/appmenu/e_mod_appmenu_private.h b/src/modules/appmenu/e_mod_appmenu_private.h index d3356aeb5..481cfe871 100644 --- a/src/modules/appmenu/e_mod_appmenu_private.h +++ b/src/modules/appmenu/e_mod_appmenu_private.h @@ -8,8 +8,8 @@ typedef struct _E_AppMenu_Window E_AppMenu_Window; typedef struct _E_AppMenu_Context { Eina_List *instances; - EDBus_Connection *conn; - EDBus_Service_Interface *iface; + Eldbus_Connection *conn; + Eldbus_Service_Interface *iface; Eina_List *windows; unsigned window_with_focus; E_AppMenu_Window *window; diff --git a/src/modules/appmenu/e_mod_dbus_registrar_server.c b/src/modules/appmenu/e_mod_dbus_registrar_server.c index 2a9f03482..2625ec965 100644 --- a/src/modules/appmenu/e_mod_dbus_registrar_server.c +++ b/src/modules/appmenu/e_mod_dbus_registrar_server.c @@ -16,7 +16,7 @@ void appmenu_application_monitor(void *data, const char *bus EINA_UNUSED, const char *old __UNUSED__, const char *new __UNUSED__) { E_AppMenu_Window *window = data; - edbus_service_signal_emit(window->ctxt->iface, SIGNAL_WINDOW_UNREGISTERED, + eldbus_service_signal_emit(window->ctxt->iface, SIGNAL_WINDOW_UNREGISTERED, window->window_id); appmenu_window_free(window); } @@ -38,16 +38,16 @@ menu_pop_cb(void *data EINA_UNUSED, const E_DBusMenu_Item *new_root_item EINA_UN //TODO } -static EDBus_Message * -_on_register_window(const EDBus_Service_Interface *iface, const EDBus_Message *msg) +static Eldbus_Message * +_on_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg) { - EDBus_Connection *conn = edbus_service_connection_get(iface); - E_AppMenu_Context *ctxt = edbus_service_object_data_get(iface, "ctxt"); + Eldbus_Connection *conn = eldbus_service_connection_get(iface); + E_AppMenu_Context *ctxt = eldbus_service_object_data_get(iface, "ctxt"); unsigned window_id; const char *path, *bus_id; E_AppMenu_Window *window; - if (!edbus_message_arguments_get(msg, "uo", &window_id, &path)) + if (!eldbus_message_arguments_get(msg, "uo", &window_id, &path)) { ERR("Error reading message"); return NULL; @@ -57,7 +57,7 @@ _on_register_window(const EDBus_Service_Interface *iface, const EDBus_Message *m EINA_SAFETY_ON_NULL_RETURN_VAL(window, NULL); - bus_id = edbus_message_sender_get(msg); + bus_id = eldbus_message_sender_get(msg); window->window_id = window_id; window->dbus_menu = e_dbusmenu_load(conn, bus_id, path, window); @@ -66,14 +66,14 @@ _on_register_window(const EDBus_Service_Interface *iface, const EDBus_Message *m window->bus_id = eina_stringshare_add(bus_id); window->path = eina_stringshare_add(path); - edbus_name_owner_changed_callback_add(conn, bus_id, appmenu_application_monitor, + eldbus_name_owner_changed_callback_add(conn, bus_id, appmenu_application_monitor, window, EINA_FALSE); ctxt->windows = eina_list_append(ctxt->windows, window); window->ctxt = ctxt; - edbus_service_signal_emit(iface, SIGNAL_WINDOW_REGISTERED, window_id, + eldbus_service_signal_emit(iface, SIGNAL_WINDOW_REGISTERED, window_id, bus_id, path); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } static E_AppMenu_Window * @@ -89,14 +89,14 @@ window_find(E_AppMenu_Context *ctxt, unsigned window_id) return NULL; } -static EDBus_Message * -_on_unregister_window(const EDBus_Service_Interface *iface, const EDBus_Message *msg) +static Eldbus_Message * +_on_unregister_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg) { - E_AppMenu_Context *ctxt = edbus_service_object_data_get(iface, "ctxt"); + E_AppMenu_Context *ctxt = eldbus_service_object_data_get(iface, "ctxt"); E_AppMenu_Window *w; unsigned window_id; - if (!edbus_message_arguments_get(msg, "u", &window_id)) + if (!eldbus_message_arguments_get(msg, "u", &window_id)) { ERR("Error reading message."); return NULL; @@ -105,19 +105,19 @@ _on_unregister_window(const EDBus_Service_Interface *iface, const EDBus_Message w = window_find(ctxt, window_id); if (w) appmenu_window_free(w); - edbus_service_signal_emit(iface, SIGNAL_WINDOW_UNREGISTERED, window_id); - return edbus_message_method_return_new(msg); + eldbus_service_signal_emit(iface, SIGNAL_WINDOW_UNREGISTERED, window_id); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -_on_getmenu(const EDBus_Service_Interface *iface, const EDBus_Message *msg) +static Eldbus_Message * +_on_getmenu(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg) { unsigned window_id; Eina_List *l; E_AppMenu_Window *w; - E_AppMenu_Context *ctxt = edbus_service_object_data_get(iface, "ctxt"); + E_AppMenu_Context *ctxt = eldbus_service_object_data_get(iface, "ctxt"); - if (!edbus_message_arguments_get(msg, "u", &window_id)) + if (!eldbus_message_arguments_get(msg, "u", &window_id)) { ERR("Error reading message"); return NULL; @@ -126,80 +126,80 @@ _on_getmenu(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { if (w->window_id == window_id) { - EDBus_Message *reply; - reply = edbus_message_method_return_new(msg); - edbus_message_arguments_append(reply, "so", w->bus_id, w->path); + Eldbus_Message *reply; + reply = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(reply, "so", w->bus_id, w->path); return reply; } } - return edbus_message_error_new(msg, ERROR_WINDOW_NOT_FOUND, ""); + return eldbus_message_error_new(msg, ERROR_WINDOW_NOT_FOUND, ""); } -static EDBus_Message * -_on_getmenus(const EDBus_Service_Interface *iface, const EDBus_Message *msg) +static Eldbus_Message * +_on_getmenus(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg) { Eina_List *l; E_AppMenu_Window *w; - E_AppMenu_Context *ctxt = edbus_service_object_data_get(iface, "ctxt"); - EDBus_Message *reply; - EDBus_Message_Iter *array, *main_iter; + E_AppMenu_Context *ctxt = eldbus_service_object_data_get(iface, "ctxt"); + Eldbus_Message *reply; + Eldbus_Message_Iter *array, *main_iter; - reply = edbus_message_method_return_new(msg); - main_iter = edbus_message_iter_get(reply); - edbus_message_iter_arguments_append(main_iter, "a(uso)", &array); + reply = eldbus_message_method_return_new(msg); + main_iter = eldbus_message_iter_get(reply); + eldbus_message_iter_arguments_append(main_iter, "a(uso)", &array); EINA_LIST_FOREACH(ctxt->windows, l, w) { - EDBus_Message_Iter *entry; - edbus_message_iter_arguments_append(array, "(uso)", &entry); - edbus_message_iter_arguments_append(entry, "uso", w->window_id, + Eldbus_Message_Iter *entry; + eldbus_message_iter_arguments_append(array, "(uso)", &entry); + eldbus_message_iter_arguments_append(entry, "uso", w->window_id, w->bus_id, w->path); - edbus_message_iter_container_close(array, entry); + eldbus_message_iter_container_close(array, entry); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } -static const EDBus_Method registrar_methods[] = { - { "RegisterWindow", EDBUS_ARGS({"u", "windowId"},{"o", "menuObjectPath"}), +static const Eldbus_Method registrar_methods[] = { + { "RegisterWindow", ELDBUS_ARGS({"u", "windowId"},{"o", "menuObjectPath"}), NULL, _on_register_window }, - { "UnregisterWindow", EDBUS_ARGS({"u", "windowId"}), + { "UnregisterWindow", ELDBUS_ARGS({"u", "windowId"}), NULL, _on_unregister_window }, - { "GetMenuForWindow", EDBUS_ARGS({"u", "windowId"}), - EDBUS_ARGS({"s", "bus_id"},{"o", "menu_path"}), _on_getmenu }, - { "GetMenus", NULL, EDBUS_ARGS({"a(uso)", "array_of_menu"}), _on_getmenus }, + { "GetMenuForWindow", ELDBUS_ARGS({"u", "windowId"}), + ELDBUS_ARGS({"s", "bus_id"},{"o", "menu_path"}), _on_getmenu }, + { "GetMenus", NULL, ELDBUS_ARGS({"a(uso)", "array_of_menu"}), _on_getmenus }, { } }; -static const EDBus_Signal registrar_signals[] = { +static const Eldbus_Signal registrar_signals[] = { [SIGNAL_WINDOW_REGISTERED] = { "WindowRegistered", - EDBUS_ARGS({"u", "windowId"}, {"s", "bus_id"}, {"o", "menu_path"}) }, + ELDBUS_ARGS({"u", "windowId"}, {"s", "bus_id"}, {"o", "menu_path"}) }, [SIGNAL_WINDOW_UNREGISTERED] = - { "WindowUnregistered", EDBUS_ARGS({"u", "windowId"}) }, + { "WindowUnregistered", ELDBUS_ARGS({"u", "windowId"}) }, { } }; -static const EDBus_Service_Interface_Desc registrar_iface = { +static const Eldbus_Service_Interface_Desc registrar_iface = { REGISTRAR_IFACE, registrar_methods, registrar_signals }; void appmenu_dbus_registrar_server_init(E_AppMenu_Context *ctx) { - ctx->iface = edbus_service_interface_register(ctx->conn, + ctx->iface = eldbus_service_interface_register(ctx->conn, REGISTRAR_PATH, ®istrar_iface); - edbus_service_object_data_set(ctx->iface, "ctxt", ctx); - edbus_name_request(ctx->conn, REGISTRAR_BUS, - EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); + eldbus_service_object_data_set(ctx->iface, "ctxt", ctx); + eldbus_name_request(ctx->conn, REGISTRAR_BUS, + ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); } void appmenu_dbus_registrar_server_shutdown(E_AppMenu_Context *ctx) { - edbus_service_interface_unregister(ctx->iface); - edbus_name_release(ctx->conn, REGISTRAR_BUS, NULL, NULL); + eldbus_service_interface_unregister(ctx->iface); + eldbus_name_release(ctx->conn, REGISTRAR_BUS, NULL, NULL); ctx->iface = NULL; } diff --git a/src/modules/appmenu/e_mod_main.c b/src/modules/appmenu/e_mod_main.c index 07cf03113..0103e59c5 100644 --- a/src/modules/appmenu/e_mod_main.c +++ b/src/modules/appmenu/e_mod_main.c @@ -165,8 +165,8 @@ e_modapi_init(E_Module *m) appmenu_module = m; - edbus_init(); - ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + eldbus_init(); + ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); event = ecore_event_handler_add(E_EVENT_BORDER_FOCUS_IN, cb_focus_in, ctxt); ctxt->events[0] = event; @@ -199,8 +199,8 @@ e_modapi_shutdown(E_Module *m) appmenu_window_free(w); appmenu_dbus_registrar_server_shutdown(ctxt); - edbus_connection_unref(ctxt->conn); - edbus_shutdown(); + eldbus_connection_unref(ctxt->conn); + eldbus_shutdown(); free(ctxt); return 1; } @@ -210,7 +210,7 @@ appmenu_window_free(E_AppMenu_Window *window) { window->ctxt->windows = eina_list_remove(window->ctxt->windows, window); e_dbusmenu_unload(window->dbus_menu); - edbus_name_owner_changed_callback_del(window->ctxt->conn, window->bus_id, + eldbus_name_owner_changed_callback_del(window->ctxt->conn, window->bus_id, appmenu_application_monitor, window); eina_stringshare_del(window->bus_id); eina_stringshare_del(window->path); diff --git a/src/modules/battery/e_mod_main.h b/src/modules/battery/e_mod_main.h index f4c96b58d..a647cf7a1 100644 --- a/src/modules/battery/e_mod_main.h +++ b/src/modules/battery/e_mod_main.h @@ -4,7 +4,7 @@ #ifdef HAVE_EEZE # include #else -# include +# include #endif typedef struct _Config Config; @@ -96,7 +96,7 @@ struct _Battery const char *model; const char *vendor; Eina_Bool got_prop:1; - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; #ifdef __OpenBSD__ int * mib; #endif @@ -107,7 +107,7 @@ struct _Ac_Adapter const char *udi; Eina_Bool present:1; const char *product; - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; #ifdef __OpenBSD__ int * mib; #endif diff --git a/src/modules/battery/e_mod_upower.c b/src/modules/battery/e_mod_upower.c index 5fcf96d89..2aa023ad9 100644 --- a/src/modules/battery/e_mod_upower.c +++ b/src/modules/battery/e_mod_upower.c @@ -9,15 +9,15 @@ extern Eina_List *device_batteries; extern Eina_List *device_ac_adapters; extern double init_time; -static EDBus_Connection *conn; -static EDBus_Proxy *upower_proxy; +static Eldbus_Connection *conn; +static Eldbus_Proxy *upower_proxy; static void _battery_free(Battery *bat) { - EDBus_Object *obj = edbus_proxy_object_get(bat->proxy); - edbus_proxy_unref(bat->proxy); - edbus_object_unref(obj); + Eldbus_Object *obj = eldbus_proxy_object_get(bat->proxy); + eldbus_proxy_unref(bat->proxy); + eldbus_object_unref(obj); device_batteries = eina_list_remove(device_batteries, bat); eina_stringshare_del(bat->udi); @@ -31,9 +31,9 @@ _battery_free(Battery *bat) static void _ac_free(Ac_Adapter *ac) { - EDBus_Object *obj = edbus_proxy_object_get(ac->proxy); - edbus_proxy_unref(ac->proxy); - edbus_object_unref(obj); + Eldbus_Object *obj = eldbus_proxy_object_get(ac->proxy); + eldbus_proxy_unref(ac->proxy); + eldbus_object_unref(obj); device_ac_adapters = eina_list_remove(device_ac_adapters, ac); eina_stringshare_del(ac->udi); @@ -41,25 +41,25 @@ _ac_free(Ac_Adapter *ac) } static void -_ac_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __UNUSED__) +_ac_get_all_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending __UNUSED__) { Ac_Adapter *ac = data; - EDBus_Message_Iter *array, *dict, *variant; + Eldbus_Message_Iter *array, *dict, *variant; - if (!edbus_message_arguments_get(msg, "a{sv}", &array)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &array)) return; - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { const char *key; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &variant)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant)) continue; if (!strcmp(key, "Online")) { Eina_Bool b; - edbus_message_iter_arguments_get(variant, "b", &b); + eldbus_message_iter_arguments_get(variant, "b", &b); ac->present = b; break; } @@ -68,28 +68,28 @@ _ac_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __UN } static void -_ac_changed_cb(void *data, const EDBus_Message *msg __UNUSED__) +_ac_changed_cb(void *data, const Eldbus_Message *msg __UNUSED__) { Ac_Adapter *ac = data; - edbus_proxy_property_get_all(ac->proxy, _ac_get_all_cb, ac); + eldbus_proxy_property_get_all(ac->proxy, _ac_get_all_cb, ac); } static void -_process_ac(EDBus_Proxy *proxy) +_process_ac(Eldbus_Proxy *proxy) { Ac_Adapter *ac; ac = E_NEW(Ac_Adapter, 1); if (!ac) goto error; ac->proxy = proxy; - ac->udi = eina_stringshare_add(edbus_object_path_get(edbus_proxy_object_get(proxy))); - edbus_proxy_property_get_all(proxy, _ac_get_all_cb, ac); - edbus_proxy_signal_handler_add(proxy, "Changed", _ac_changed_cb, ac); + ac->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy))); + eldbus_proxy_property_get_all(proxy, _ac_get_all_cb, ac); + eldbus_proxy_signal_handler_add(proxy, "Changed", _ac_changed_cb, ac); device_ac_adapters = eina_list_append(device_ac_adapters, ac); return; error: - edbus_object_unref(edbus_proxy_object_get(proxy)); - edbus_proxy_unref(proxy); + eldbus_object_unref(eldbus_proxy_object_get(proxy)); + eldbus_proxy_unref(proxy); return; } @@ -104,15 +104,15 @@ static const char *bat_techologies[] = { }; static void -_bat_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __UNUSED__) +_bat_get_all_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending __UNUSED__) { Battery *bat = data; - EDBus_Message_Iter *array, *dict, *variant; + Eldbus_Message_Iter *array, *dict, *variant; bat->got_prop = EINA_TRUE; - if (!edbus_message_arguments_get(msg, "a{sv}", &array)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &array)) return; - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { const char *key; union @@ -124,16 +124,16 @@ _bat_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U const char *s; } val; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &variant)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant)) continue; if (!strcmp(key, "IsPresent")) { - edbus_message_iter_arguments_get(variant, "b", &val.b); + eldbus_message_iter_arguments_get(variant, "b", &val.b); bat->present = val.b; } else if (!strcmp(key, "TimeToEmpty")) { - edbus_message_iter_arguments_get(variant, "x", &val.i64); + eldbus_message_iter_arguments_get(variant, "x", &val.i64); bat->time_left = (int) val.i64; if (bat->time_left > 0) bat->charging = EINA_FALSE; @@ -142,45 +142,45 @@ _bat_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U } else if (!strcmp(key, "Percentage")) { - edbus_message_iter_arguments_get(variant, "d", &val.d); + eldbus_message_iter_arguments_get(variant, "d", &val.d); bat->percent = (int) val.d; } else if (!strcmp(key, "Energy")) { - edbus_message_iter_arguments_get(variant, "d", &val.d); + eldbus_message_iter_arguments_get(variant, "d", &val.d); bat->current_charge = (int) val.d; } else if (!strcmp(key, "EnergyFullDesign")) { - edbus_message_iter_arguments_get(variant, "d", &val.d); + eldbus_message_iter_arguments_get(variant, "d", &val.d); bat->design_charge = (int) val.d; } else if (!strcmp(key, "EnergyFull")) { - edbus_message_iter_arguments_get(variant, "d", &val.d); + eldbus_message_iter_arguments_get(variant, "d", &val.d); bat->last_full_charge = (int) val.d; } else if (!strcmp(key, "TimeToFull")) { - edbus_message_iter_arguments_get(variant, "x", &val.i64); + eldbus_message_iter_arguments_get(variant, "x", &val.i64); bat->time_full = (int) val.i64; } else if (!strcmp(key, "Technology")) { - edbus_message_iter_arguments_get(variant, "u", &val.u); + eldbus_message_iter_arguments_get(variant, "u", &val.u); if (val.u > EINA_C_ARRAY_LENGTH(bat_techologies)) val.u = 0; bat->technology = bat_techologies[val.u]; } else if (!strcmp(key, "Model")) { - if (!edbus_message_iter_arguments_get(variant, "s", &val.s)) + if (!eldbus_message_iter_arguments_get(variant, "s", &val.s)) continue; eina_stringshare_replace(&bat->model, val.s); } else if (!strcmp(key, "Vendor")) { - if (!edbus_message_iter_arguments_get(variant, "s", &val.s)) + if (!eldbus_message_iter_arguments_get(variant, "s", &val.s)) continue; if (bat->vendor) eina_stringshare_del(bat->vendor); @@ -191,45 +191,45 @@ _bat_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U } static void -_bat_changed_cb(void *data, const EDBus_Message *msg __UNUSED__) +_bat_changed_cb(void *data, const Eldbus_Message *msg __UNUSED__) { Battery *bat = data; - edbus_proxy_property_get_all(bat->proxy, _bat_get_all_cb, bat); + eldbus_proxy_property_get_all(bat->proxy, _bat_get_all_cb, bat); } static void -_process_battery(EDBus_Proxy *proxy) +_process_battery(Eldbus_Proxy *proxy) { Battery *bat; bat = E_NEW(Battery, 1); if (!bat) { - edbus_object_unref(edbus_proxy_object_get(proxy)); - edbus_proxy_unref(proxy); + eldbus_object_unref(eldbus_proxy_object_get(proxy)); + eldbus_proxy_unref(proxy); return; } bat->proxy = proxy; - bat->udi = eina_stringshare_add(edbus_object_path_get(edbus_proxy_object_get(proxy))); - edbus_proxy_property_get_all(proxy, _bat_get_all_cb, bat); - edbus_proxy_signal_handler_add(proxy, "Changed", _bat_changed_cb, bat); + bat->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy))); + eldbus_proxy_property_get_all(proxy, _bat_get_all_cb, bat); + eldbus_proxy_signal_handler_add(proxy, "Changed", _bat_changed_cb, bat); device_batteries = eina_list_append(device_batteries, bat); _battery_device_update(); } static void -_device_type_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __UNUSED__) +_device_type_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending __UNUSED__) { - EDBus_Proxy *proxy = data; - EDBus_Message_Iter *variant; - EDBus_Object *obj; + Eldbus_Proxy *proxy = data; + Eldbus_Message_Iter *variant; + Eldbus_Object *obj; unsigned int type; - if (!edbus_message_arguments_get(msg, "v", &variant)) + if (!eldbus_message_arguments_get(msg, "v", &variant)) goto error; - edbus_message_iter_arguments_get(variant, "u", &type); + eldbus_message_iter_arguments_get(variant, "u", &type); if (type == 1) _process_ac(proxy); else if (type == 2) @@ -240,55 +240,55 @@ _device_type_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U return; error: - obj = edbus_proxy_object_get(proxy); - edbus_proxy_unref(proxy); - edbus_object_unref(obj); + obj = eldbus_proxy_object_get(proxy); + eldbus_proxy_unref(proxy); + eldbus_object_unref(obj); return; } static void _process_enumerate_path(const char *path) { - EDBus_Object *obj; - EDBus_Proxy *proxy; + Eldbus_Object *obj; + Eldbus_Proxy *proxy; - obj = edbus_object_get(conn, BUS, path); + obj = eldbus_object_get(conn, BUS, path); EINA_SAFETY_ON_FALSE_RETURN(obj); - proxy = edbus_proxy_get(obj, "org.freedesktop.UPower.Device"); - edbus_proxy_property_get(proxy, "Type", _device_type_cb, proxy); + proxy = eldbus_proxy_get(obj, "org.freedesktop.UPower.Device"); + eldbus_proxy_property_get(proxy, "Type", _device_type_cb, proxy); } static void -_enumerate_cb(void *data __UNUSED__, const EDBus_Message *msg, EDBus_Pending *pending __UNUSED__) +_enumerate_cb(void *data __UNUSED__, const Eldbus_Message *msg, Eldbus_Pending *pending __UNUSED__) { const char *path; - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; - if (!edbus_message_arguments_get(msg, "ao", &array)) + if (!eldbus_message_arguments_get(msg, "ao", &array)) return; - while (edbus_message_iter_get_and_next(array, 'o', &path)) + while (eldbus_message_iter_get_and_next(array, 'o', &path)) _process_enumerate_path(path); } static void -_device_added_cb(void *data __UNUSED__, const EDBus_Message *msg) +_device_added_cb(void *data __UNUSED__, const Eldbus_Message *msg) { const char *path; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; _process_enumerate_path(path); } static void -_device_removed_cb(void *data __UNUSED__, const EDBus_Message *msg) +_device_removed_cb(void *data __UNUSED__, const Eldbus_Message *msg) { Battery *bat; Ac_Adapter *ac; const char *path; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; bat = _battery_battery_find(path); if (bat) @@ -308,26 +308,26 @@ _device_removed_cb(void *data __UNUSED__, const EDBus_Message *msg) int _battery_upower_start(void) { - EDBus_Object *obj; + Eldbus_Object *obj; - edbus_init(); - conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); + eldbus_init(); + conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); EINA_SAFETY_ON_NULL_RETURN_VAL(conn, 0); - obj = edbus_object_get(conn, BUS, PATH); + obj = eldbus_object_get(conn, BUS, PATH); EINA_SAFETY_ON_NULL_GOTO(obj, obj_error); - upower_proxy = edbus_proxy_get(obj, IFACE); + upower_proxy = eldbus_proxy_get(obj, IFACE); EINA_SAFETY_ON_NULL_GOTO(upower_proxy, proxy_error); - edbus_proxy_call(upower_proxy, "EnumerateDevices", _enumerate_cb, NULL, -1, ""); - edbus_proxy_signal_handler_add(upower_proxy, "DeviceAdded", _device_added_cb, NULL); - edbus_proxy_signal_handler_add(upower_proxy, "DeviceRemoved", _device_removed_cb, NULL); + eldbus_proxy_call(upower_proxy, "EnumerateDevices", _enumerate_cb, NULL, -1, ""); + eldbus_proxy_signal_handler_add(upower_proxy, "DeviceAdded", _device_added_cb, NULL); + eldbus_proxy_signal_handler_add(upower_proxy, "DeviceRemoved", _device_removed_cb, NULL); return 1; proxy_error: - edbus_object_unref(obj); + eldbus_object_unref(obj); obj_error: - edbus_connection_unref(conn); + eldbus_connection_unref(conn); return 0; } @@ -337,16 +337,16 @@ _battery_upower_stop(void) Eina_List *list, *list2; Battery *bat; Ac_Adapter *ac; - EDBus_Object *obj; + Eldbus_Object *obj; EINA_LIST_FOREACH_SAFE(device_batteries, list, list2, bat) _battery_free(bat); EINA_LIST_FOREACH_SAFE(device_ac_adapters, list, list2, ac) _ac_free(ac); - obj = edbus_proxy_object_get(upower_proxy); - edbus_proxy_unref(upower_proxy); - edbus_object_unref(obj); - edbus_connection_unref(conn); - edbus_shutdown(); + obj = eldbus_proxy_object_get(upower_proxy); + eldbus_proxy_unref(upower_proxy); + eldbus_object_unref(obj); + eldbus_connection_unref(conn); + eldbus_shutdown(); } diff --git a/src/modules/bluez4/agent.c b/src/modules/bluez4/agent.c index 2a72e5fc3..e7fd227fe 100644 --- a/src/modules/bluez4/agent.c +++ b/src/modules/bluez4/agent.c @@ -5,45 +5,45 @@ #define AGENT_INTERFACE "org.bluez.Agent" #define BLUEZ_ERROR_FAILED "org.bluez.Error.Failed" -#define GET_ERROR_MSG "edbus_message_arguments_get() error" +#define GET_ERROR_MSG "eldbus_message_arguments_get() error" #define BLUEZ_ERROR_REJECTED "org.bluez.Error.Rejected" #define REJECTED_MSG "Request was rejected" -static EDBus_Connection *bluez_conn; +static Eldbus_Connection *bluez_conn; static char buf[1024]; /* Local Functions */ static void -_reply(EDBus_Message *message, EDBus_Message *reply) +_reply(Eldbus_Message *message, Eldbus_Message *reply) { - edbus_connection_send(bluez_conn, reply, NULL, NULL, -1); - edbus_message_unref(message); + eldbus_connection_send(bluez_conn, reply, NULL, NULL, -1); + eldbus_message_unref(message); } static void _pincode_ok(void *data, char *text) { - EDBus_Message *message = data; - EDBus_Message *reply = edbus_message_method_return_new(message); - edbus_message_arguments_append(reply, "s", text); + Eldbus_Message *message = data; + Eldbus_Message *reply = eldbus_message_method_return_new(message); + eldbus_message_arguments_append(reply, "s", text); _reply(message, reply); } static void _passkey_ok(void *data, char *text) { - EDBus_Message *message = data; + Eldbus_Message *message = data; uint32_t passkey = (uint32_t)atoi(text); - EDBus_Message *reply = edbus_message_method_return_new(message); - edbus_message_arguments_append(reply, "u", passkey); + Eldbus_Message *reply = eldbus_message_method_return_new(message); + eldbus_message_arguments_append(reply, "u", passkey); _reply(message, reply); } static void _cancel(void *data) { - EDBus_Message *message = data; - EDBus_Message *reply = edbus_message_error_new(message, + Eldbus_Message *message = data; + Eldbus_Message *reply = eldbus_message_error_new(message, BLUEZ_ERROR_REJECTED, REJECTED_MSG); _reply(message, reply); } @@ -73,9 +73,9 @@ _display_msg(const char *title, const char *msg) } static void -_reply_and_del_dialog(EDBus_Message *reply, E_Dialog *dialog) +_reply_and_del_dialog(Eldbus_Message *reply, E_Dialog *dialog) { - EDBus_Message *message = dialog->data; + Eldbus_Message *message = dialog->data; _reply(message, reply); if (!dialog) return; e_object_del(E_OBJECT(dialog)); @@ -84,8 +84,8 @@ _reply_and_del_dialog(EDBus_Message *reply, E_Dialog *dialog) static void _reject(void *data, E_Dialog *dialog) { - const EDBus_Message *msg = dialog->data; - EDBus_Message *reply = edbus_message_error_new(msg, BLUEZ_ERROR_REJECTED, + const Eldbus_Message *msg = dialog->data; + Eldbus_Message *reply = eldbus_message_error_new(msg, BLUEZ_ERROR_REJECTED, REJECTED_MSG); _reply_and_del_dialog(reply, dialog); } @@ -93,8 +93,8 @@ _reject(void *data, E_Dialog *dialog) static void _ok(void *data, E_Dialog *dialog) { - const EDBus_Message *msg = dialog->data; - EDBus_Message *reply = edbus_message_method_return_new(msg); + const Eldbus_Message *msg = dialog->data; + Eldbus_Message *reply = eldbus_message_method_return_new(msg); _reply_and_del_dialog(reply, dialog); } @@ -107,10 +107,10 @@ _close(E_Win *win) static void _ask(const char *title, const char *ask_msg, const char *ok_label, - EDBus_Message *edbus_message) + Eldbus_Message *eldbus_message) { E_Dialog *dialog = _create_dialog(title, ask_msg, "dialog-ask", "ask"); - dialog->data = edbus_message; + dialog->data = eldbus_message; e_win_delete_callback_set(dialog->win, _close); e_dialog_button_add(dialog, ok_label, NULL, _ok, NULL); e_dialog_button_add(dialog, "Reject", NULL, _reject, NULL); @@ -118,18 +118,18 @@ _ask(const char *title, const char *ask_msg, const char *ok_label, } /* Implementation of agent API */ -static EDBus_Message * -_agent_release(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_release(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { DBG("Agent Released."); - return edbus_message_method_return_new(message); + return eldbus_message_method_return_new(message); } -static EDBus_Message * -_agent_request_pin_code(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_request_pin_code(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { - EDBus_Message *msg = (EDBus_Message *)message; - edbus_message_ref(msg); + Eldbus_Message *msg = (Eldbus_Message *)message; + eldbus_message_ref(msg); e_entry_dialog_show("Pin Code Requested", NULL, "Enter the PinCode above. It should have 1-16 " "characters and can be alphanumeric.", "0000", @@ -137,115 +137,115 @@ _agent_request_pin_code(const EDBus_Service_Interface *iface, const EDBus_Messag return NULL; } -static EDBus_Message * -_agent_request_passkey(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_request_passkey(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { - EDBus_Message *msg = (EDBus_Message *)message; - edbus_message_ref(msg); + Eldbus_Message *msg = (Eldbus_Message *)message; + eldbus_message_ref(msg); e_entry_dialog_show("Passkey Requested", NULL, "Enter the Passkey above. " "It should be a numeric value between 0-999999.", "0", "OK", "Cancel", _passkey_ok, _cancel, msg); return NULL; } -static EDBus_Message * -_agent_display_passkey(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_display_passkey(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { const char *device; uint32_t passkey; uint16_t entered; Device *dev; - if(!edbus_message_arguments_get(message, "ouq", &device, &passkey, &entered)) - return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); + if(!eldbus_message_arguments_get(message, "ouq", &device, &passkey, &entered)) + return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); snprintf(buf, sizeof(buf), "%d keys were typed on %s. Passkey is %06d", entered, dev->name, passkey); _display_msg("Display Passkey", buf); - return edbus_message_method_return_new(message); + return eldbus_message_method_return_new(message); } -static EDBus_Message * -_agent_display_pin_code(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_display_pin_code(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { const char *device, *pincode; Device *dev; - if(!edbus_message_arguments_get(message, "os", &device, &pincode)) - return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); + if(!eldbus_message_arguments_get(message, "os", &device, &pincode)) + return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); snprintf(buf, sizeof(buf), "Pincode for %s is %s", dev->name, pincode); _display_msg("Display Pincode", buf); - return edbus_message_method_return_new(message); + return eldbus_message_method_return_new(message); } -static EDBus_Message * -_agent_request_confirmation(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_request_confirmation(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { const char *device; uint32_t passkey; Device *dev; - if(!edbus_message_arguments_get(message, "ou", &device, &passkey)) - return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); + if(!eldbus_message_arguments_get(message, "ou", &device, &passkey)) + return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); snprintf(buf, sizeof(buf), "%06d is the passkey presented in %s?", passkey, dev->name); - edbus_message_ref((EDBus_Message *)message); - _ask("Confirm Request", buf, "Confirm", (EDBus_Message *)message); + eldbus_message_ref((Eldbus_Message *)message); + _ask("Confirm Request", buf, "Confirm", (Eldbus_Message *)message); return NULL; } -static EDBus_Message * -_agent_authorize(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_authorize(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { const char *device, *uuid; Device *dev; - if(!edbus_message_arguments_get(message, "os", &device, &uuid)) - return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); + if(!eldbus_message_arguments_get(message, "os", &device, &uuid)) + return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); snprintf(buf, sizeof(buf), "Grant permission for %s to connect?", dev->name); - edbus_message_ref((EDBus_Message *)message); - _ask("Authorize Connection", buf, "Grant", (EDBus_Message *)message); + eldbus_message_ref((Eldbus_Message *)message); + _ask("Authorize Connection", buf, "Grant", (Eldbus_Message *)message); return NULL; } -static EDBus_Message * -_agent_cancel(const EDBus_Service_Interface *iface, const EDBus_Message *message) +static Eldbus_Message * +_agent_cancel(const Eldbus_Service_Interface *iface, const Eldbus_Message *message) { DBG("Request canceled."); - return edbus_message_method_return_new(message); + return eldbus_message_method_return_new(message); } -static const EDBus_Method agent_methods[] = { +static const Eldbus_Method agent_methods[] = { { "Release", NULL, NULL, _agent_release }, - { "RequestPinCode", EDBUS_ARGS({"o", "device"}), - EDBUS_ARGS({"s", "pincode"}), _agent_request_pin_code }, - { "RequestPasskey", EDBUS_ARGS({"o", "device"}), - EDBUS_ARGS({"u", "passkey"}), _agent_request_passkey }, + { "RequestPinCode", ELDBUS_ARGS({"o", "device"}), + ELDBUS_ARGS({"s", "pincode"}), _agent_request_pin_code }, + { "RequestPasskey", ELDBUS_ARGS({"o", "device"}), + ELDBUS_ARGS({"u", "passkey"}), _agent_request_passkey }, { "DisplayPasskey", - EDBUS_ARGS({"o", "device"},{"u", "passkey"},{"q", "entered"}), + ELDBUS_ARGS({"o", "device"},{"u", "passkey"},{"q", "entered"}), NULL, _agent_display_passkey }, - { "DisplayPinCode", EDBUS_ARGS({"o", "device"},{"s", "pincode"}), + { "DisplayPinCode", ELDBUS_ARGS({"o", "device"},{"s", "pincode"}), NULL, _agent_display_pin_code }, - { "RequestConfirmation", EDBUS_ARGS({"o", "device"},{"u", "passkey"}), + { "RequestConfirmation", ELDBUS_ARGS({"o", "device"},{"u", "passkey"}), NULL, _agent_request_confirmation }, - { "Authorize", EDBUS_ARGS({"o", "device"},{"s", "uuid"}), + { "Authorize", ELDBUS_ARGS({"o", "device"},{"s", "uuid"}), NULL, _agent_authorize }, { "Cancel", NULL, NULL, _agent_cancel }, { } }; -static const EDBus_Service_Interface_Desc agent_iface = { +static const Eldbus_Service_Interface_Desc agent_iface = { AGENT_INTERFACE, agent_methods }; /* Public Functions */ -void ebluez4_register_agent_interfaces(EDBus_Connection *conn) +void ebluez4_register_agent_interfaces(Eldbus_Connection *conn) { bluez_conn = conn; - edbus_service_interface_register(conn, AGENT_PATH, &agent_iface); - edbus_service_interface_register(conn, REMOTE_AGENT_PATH, &agent_iface); + eldbus_service_interface_register(conn, AGENT_PATH, &agent_iface); + eldbus_service_interface_register(conn, REMOTE_AGENT_PATH, &agent_iface); } diff --git a/src/modules/bluez4/agent.h b/src/modules/bluez4/agent.h index a7e45c621..6efd1e91b 100644 --- a/src/modules/bluez4/agent.h +++ b/src/modules/bluez4/agent.h @@ -1,6 +1,6 @@ -#include "EDBus.h" +#include "Eldbus.h" #define AGENT_PATH "/org/bluez/Agent" #define REMOTE_AGENT_PATH "/org/bluez/RemoteAgent" -void ebluez4_register_agent_interfaces(EDBus_Connection *conn); +void ebluez4_register_agent_interfaces(Eldbus_Connection *conn); diff --git a/src/modules/bluez4/e_mod_main.c b/src/modules/bluez4/e_mod_main.c index 49a57cadc..73628e272 100644 --- a/src/modules/bluez4/e_mod_main.c +++ b/src/modules/bluez4/e_mod_main.c @@ -1,5 +1,5 @@ #include -#include +#include #include "e_mod_main.h" #include "ebluez4.h" @@ -686,7 +686,7 @@ e_modapi_init(E_Module *m) if (!ebluez4_config) ebluez4_config = E_NEW(Config, 1); - ebluez4_edbus_init(); + ebluez4_eldbus_init(); e_gadcon_provider_register(&_gc_class); @@ -721,7 +721,7 @@ e_modapi_shutdown(E_Module *m) free(ebluez4_config); ebluez4_config = NULL; - ebluez4_edbus_shutdown(); + ebluez4_eldbus_shutdown(); e_gadcon_provider_unregister(&_gc_class); return 1; } diff --git a/src/modules/bluez4/ebluez4.c b/src/modules/bluez4/ebluez4.c index e10ccbe48..af509108f 100644 --- a/src/modules/bluez4/ebluez4.c +++ b/src/modules/bluez4/ebluez4.c @@ -32,7 +32,7 @@ _adap_path_cmp(const void *d1, const void *d2) const Adapter *adap = d1; const char *path = d2; - return strcmp(edbus_object_path_get(adap->obj), path); + return strcmp(eldbus_object_path_get(adap->obj), path); } static struct icon_type @@ -71,12 +71,12 @@ _icon_to_type(const char *icon) static void _free_dev(Device *dev) { - if (dev->proxy.input) edbus_proxy_unref(dev->proxy.input); - if (dev->proxy.audio_source) edbus_proxy_unref(dev->proxy.audio_source); - if (dev->proxy.audio_sink) edbus_proxy_unref(dev->proxy.audio_sink); + if (dev->proxy.input) eldbus_proxy_unref(dev->proxy.input); + if (dev->proxy.audio_source) eldbus_proxy_unref(dev->proxy.audio_source); + if (dev->proxy.audio_sink) eldbus_proxy_unref(dev->proxy.audio_sink); if (dev->obj) - edbus_object_unref(dev->obj); + eldbus_object_unref(dev->obj); eina_stringshare_del(dev->addr); dev->addr = NULL; eina_stringshare_del(dev->name); @@ -87,8 +87,8 @@ _free_dev(Device *dev) static void _free_adap(Adapter *adap) { - edbus_proxy_unref(adap->proxy); - edbus_object_unref(adap->obj); + eldbus_proxy_unref(adap->proxy); + eldbus_object_unref(adap->obj); eina_stringshare_del(adap->name); adap->name = NULL; ebluez4_adapter_settings_del(adap->dialog); @@ -127,25 +127,25 @@ _uuid_to_profile(const char *uuid) } static void -_set_dev_services(Device *dev, EDBus_Message_Iter *uuids) +_set_dev_services(Device *dev, Eldbus_Message_Iter *uuids) { const char *uuid; - while (edbus_message_iter_get_and_next(uuids, 's', &uuid)) + while (eldbus_message_iter_get_and_next(uuids, 's', &uuid)) switch (_uuid_to_profile(uuid)) { case INPUT: if (!dev->proxy.input) - dev->proxy.input = edbus_proxy_get(dev->obj, INPUT_INTERFACE); + dev->proxy.input = eldbus_proxy_get(dev->obj, INPUT_INTERFACE); break; case AUDIO_SOURCE: if (!dev->proxy.audio_source) - dev->proxy.audio_source = edbus_proxy_get(dev->obj, + dev->proxy.audio_source = eldbus_proxy_get(dev->obj, AUDIO_SOURCE_INTERFACE); break; case AUDIO_SINK: if (!dev->proxy.audio_sink) - dev->proxy.audio_sink = edbus_proxy_get(dev->obj, + dev->proxy.audio_sink = eldbus_proxy_get(dev->obj, AUDIO_SINK_INTERFACE); break; default: @@ -154,65 +154,65 @@ _set_dev_services(Device *dev, EDBus_Message_Iter *uuids) } static void -_retrieve_properties(EDBus_Message_Iter *dict, const char **addr, +_retrieve_properties(Eldbus_Message_Iter *dict, const char **addr, const char **name, const char **icon, Eina_Bool *paired, - Eina_Bool *connected, EDBus_Message_Iter **uuids) + Eina_Bool *connected, Eldbus_Message_Iter **uuids) { - EDBus_Message_Iter *entry, *variant; + Eldbus_Message_Iter *entry, *variant; const char *key; *icon = NULL; - while (edbus_message_iter_get_and_next(dict, 'e', &entry)) + while (eldbus_message_iter_get_and_next(dict, 'e', &entry)) { - if (!edbus_message_iter_arguments_get(entry, "sv", &key, &variant)) + if (!eldbus_message_iter_arguments_get(entry, "sv", &key, &variant)) return; if (!strcmp(key, "Address")) { - if (!edbus_message_iter_arguments_get(variant, "s", addr)) + if (!eldbus_message_iter_arguments_get(variant, "s", addr)) return; } else if (!strcmp(key, "Name")) { - if (!edbus_message_iter_arguments_get(variant, "s", name)) + if (!eldbus_message_iter_arguments_get(variant, "s", name)) return; } else if (!strcmp(key, "Icon")) { - if (!edbus_message_iter_arguments_get(variant, "s", icon)) + if (!eldbus_message_iter_arguments_get(variant, "s", icon)) return; } else if (!strcmp(key, "Paired")) { - if (!edbus_message_iter_arguments_get(variant, "b", paired)) + if (!eldbus_message_iter_arguments_get(variant, "b", paired)) return; } else if (!strcmp(key, "Connected")) { - if (!edbus_message_iter_arguments_get(variant, "b", connected)) + if (!eldbus_message_iter_arguments_get(variant, "b", connected)) return; } else if (!strcmp(key, "UUIDs")) { - if (!edbus_message_iter_arguments_get(variant, "as", uuids)) + if (!eldbus_message_iter_arguments_get(variant, "as", uuids)) return; } } } static void -_on_dev_property_changed(void *context, const EDBus_Message *msg) +_on_dev_property_changed(void *context, const Eldbus_Message *msg) { const char *key, *name, *icon; char err_msg[4096]; Eina_Bool paired, connected; - EDBus_Message_Iter *variant, *uuids; + Eldbus_Message_Iter *variant, *uuids; Device *dev = context; Device *found_dev = eina_list_search_unsorted(ctxt->found_devices, _dev_addr_cmp, dev->addr); - if (!edbus_message_arguments_get(msg, "sv", &key, &variant)) + if (!eldbus_message_arguments_get(msg, "sv", &key, &variant)) { snprintf(err_msg, sizeof(err_msg), "Property of %s changed, but could not be read", dev->name); @@ -223,7 +223,7 @@ _on_dev_property_changed(void *context, const EDBus_Message *msg) if (!strcmp(key, "Name")) { - if (!edbus_message_iter_arguments_get(variant, "s", &name)) + if (!eldbus_message_iter_arguments_get(variant, "s", &name)) return; DBG("'%s' property of %s changed to %s", key, dev->name, name); eina_stringshare_replace(&dev->name, name); @@ -236,7 +236,7 @@ _on_dev_property_changed(void *context, const EDBus_Message *msg) } else if (!strcmp(key, "Icon")) { - if (!edbus_message_iter_arguments_get(variant, "s", &icon)) + if (!eldbus_message_iter_arguments_get(variant, "s", &icon)) return; if (!found_dev) return; DBG("'%s' property of %s changed to %s", key, found_dev->name, icon); @@ -245,7 +245,7 @@ _on_dev_property_changed(void *context, const EDBus_Message *msg) } else if (!strcmp(key, "Paired")) { - if (!edbus_message_iter_arguments_get(variant, "b", &paired)) + if (!eldbus_message_iter_arguments_get(variant, "b", &paired)) return; DBG("'%s' property of %s changed to %d", key, dev->name, paired); dev->paired = paired; @@ -258,25 +258,25 @@ _on_dev_property_changed(void *context, const EDBus_Message *msg) } else if (!strcmp(key, "Connected")) { - if (!edbus_message_iter_arguments_get(variant, "b", &connected)) + if (!eldbus_message_iter_arguments_get(variant, "b", &connected)) return; DBG("'%s' property of %s changed to %d", key, dev->name, connected); dev->connected = connected; } else if (!strcmp(key, "UUIDs")) { - if (!edbus_message_iter_arguments_get(variant, "as", &uuids)) + if (!eldbus_message_iter_arguments_get(variant, "as", &uuids)) return; _set_dev_services(dev, uuids); } } static void -_on_connected(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_connected(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { const char *err_name, *err_msg; - if (edbus_message_error_get(msg, &err_name, &err_msg)) + if (eldbus_message_error_get(msg, &err_name, &err_msg)) { ERR("%s: %s", err_name, err_msg); ebluez4_show_error(err_name, err_msg); @@ -285,18 +285,18 @@ _on_connected(void *data, const EDBus_Message *msg, EDBus_Pending *pending) } static void -_try_to_connect(EDBus_Proxy *proxy) +_try_to_connect(Eldbus_Proxy *proxy) { if (proxy) - edbus_proxy_call(proxy, "Connect", _on_connected, NULL, -1, ""); + eldbus_proxy_call(proxy, "Connect", _on_connected, NULL, -1, ""); } static void -_on_disconnected(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_disconnected(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { const char *err_name, *err_msg; - if (edbus_message_error_get(msg, &err_name, &err_msg)) + if (eldbus_message_error_get(msg, &err_name, &err_msg)) { ERR("%s: %s", err_name, err_msg); ebluez4_show_error(err_name, err_msg); @@ -305,20 +305,20 @@ _on_disconnected(void *data, const EDBus_Message *msg, EDBus_Pending *pending) } static void -_try_to_disconnect(EDBus_Proxy *proxy) +_try_to_disconnect(Eldbus_Proxy *proxy) { if (proxy) - edbus_proxy_call(proxy, "Disconnect", _on_disconnected, NULL, -1, ""); + eldbus_proxy_call(proxy, "Disconnect", _on_disconnected, NULL, -1, ""); } static void -_on_paired(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_paired(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { const char *err_name, *err_msg; Pair_Cb *d = data; Eina_Bool success = EINA_TRUE; - if (edbus_message_error_get(msg, &err_name, &err_msg)) + if (eldbus_message_error_get(msg, &err_name, &err_msg)) { ERR("%s: %s", err_name, err_msg); success = EINA_FALSE; @@ -328,15 +328,15 @@ _on_paired(void *data, const EDBus_Message *msg, EDBus_Pending *pending) } static void -_on_dev_properties(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_dev_properties(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { - EDBus_Message_Iter *dict, *uuids; + Eldbus_Message_Iter *dict, *uuids; const char *addr, *name, *icon; Eina_Bool paired; Eina_Bool connected; Device *dev = data; - if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &dict)) return; _retrieve_properties(dict, &addr, &name, &icon, &paired, &connected, &uuids); @@ -363,22 +363,22 @@ _set_dev(const char *path) { Device *dev = calloc(1, sizeof(Device)); - dev->obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, path); - dev->proxy.dev = edbus_proxy_get(dev->obj, DEVICE_INTERFACE); - edbus_proxy_call(dev->proxy.dev, "GetProperties", _on_dev_properties, dev, + dev->obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, path); + dev->proxy.dev = eldbus_proxy_get(dev->obj, DEVICE_INTERFACE); + eldbus_proxy_call(dev->proxy.dev, "GetProperties", _on_dev_properties, dev, -1, ""); - edbus_proxy_signal_handler_add(dev->proxy.dev, "PropertyChanged", + eldbus_proxy_signal_handler_add(dev->proxy.dev, "PropertyChanged", _on_dev_property_changed, dev); ctxt->devices = eina_list_append(ctxt->devices, dev); } static void -_on_removed(void *context, const EDBus_Message *msg) +_on_removed(void *context, const Eldbus_Message *msg) { const char *path; Device *dev, *fdev; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, path); @@ -390,25 +390,25 @@ _on_removed(void *context, const EDBus_Message *msg) } static void -_on_created(void *context, const EDBus_Message *msg) +_on_created(void *context, const Eldbus_Message *msg) { const char *path; - if (!edbus_message_arguments_get(msg, "o", &path)) + if (!eldbus_message_arguments_get(msg, "o", &path)) return; _set_dev(path); } static void -_on_device_found(void *context, const EDBus_Message *msg) +_on_device_found(void *context, const Eldbus_Message *msg) { - EDBus_Message_Iter *dict, *uuids; + Eldbus_Message_Iter *dict, *uuids; const char *addr, *name, *icon; Eina_Bool paired, connected; Device *dev; - if (!edbus_message_arguments_get(msg, "sa{sv}", &addr, &dict)) + if (!eldbus_message_arguments_get(msg, "sa{sv}", &addr, &dict)) return; if (eina_list_search_unsorted(ctxt->found_devices, _dev_addr_cmp, addr)) @@ -427,33 +427,33 @@ _on_device_found(void *context, const EDBus_Message *msg) } static void -_on_list_devices(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_list_devices(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; const char *path; const char *err_msg = "Error reading list of devices"; - if (!edbus_message_arguments_get(msg, "ao", &array)) + if (!eldbus_message_arguments_get(msg, "ao", &array)) { ERR("%s", err_msg); ebluez4_show_error("Bluez Error", err_msg); return; } - while (edbus_message_iter_get_and_next(array, 'o', &path)) + while (eldbus_message_iter_get_and_next(array, 'o', &path)) _set_dev(path); } static void -_on_adap_property_changed(void *context, const EDBus_Message *msg) +_on_adap_property_changed(void *context, const Eldbus_Message *msg) { const char *key, *name; char err_msg[1096]; Eina_Bool visible, pairable, powered; - EDBus_Message_Iter *variant; + Eldbus_Message_Iter *variant; Adapter *adap = context; - if (!edbus_message_arguments_get(msg, "sv", &key, &variant)) + if (!eldbus_message_arguments_get(msg, "sv", &key, &variant)) { snprintf(err_msg, sizeof(err_msg), "Property of %s changed, but could not be read", adap->name); @@ -464,7 +464,7 @@ _on_adap_property_changed(void *context, const EDBus_Message *msg) if (!strcmp(key, "Name")) { - if (!edbus_message_iter_arguments_get(variant, "s", &name)) + if (!eldbus_message_iter_arguments_get(variant, "s", &name)) return; DBG("'%s' property of %s changed to %s", key, adap->name, name); eina_stringshare_del(adap->name); @@ -474,21 +474,21 @@ _on_adap_property_changed(void *context, const EDBus_Message *msg) } else if (!strcmp(key, "Discoverable")) { - if (!edbus_message_iter_arguments_get(variant, "b", &visible)) + if (!eldbus_message_iter_arguments_get(variant, "b", &visible)) return; DBG("'%s' property of %s changed to %d", key, adap->name, visible); adap->visible = visible; } else if (!strcmp(key, "Pairable")) { - if (!edbus_message_iter_arguments_get(variant, "b", &pairable)) + if (!eldbus_message_iter_arguments_get(variant, "b", &pairable)) return; DBG("'%s' property of %s changed to %d", key, adap->name, pairable); adap->pairable = pairable; } else if (!strcmp(key, "Powered")) { - if (!edbus_message_iter_arguments_get(variant, "b", &powered)) + if (!eldbus_message_iter_arguments_get(variant, "b", &powered)) return; DBG("'%s' property of %s changed to %d", key, adap->name, powered); adap->powered = powered; @@ -498,39 +498,39 @@ _on_adap_property_changed(void *context, const EDBus_Message *msg) } static void -_on_adap_properties(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_adap_properties(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { - EDBus_Message_Iter *dict, *entry, *variant; + Eldbus_Message_Iter *dict, *entry, *variant; const char *name, *key; Eina_Bool visible, pairable, powered; Adapter *adap = data; - if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &dict)) return; - while (edbus_message_iter_get_and_next(dict, 'e', &entry)) + while (eldbus_message_iter_get_and_next(dict, 'e', &entry)) { - if (!edbus_message_iter_arguments_get(entry, "sv", &key, &variant)) + if (!eldbus_message_iter_arguments_get(entry, "sv", &key, &variant)) return; else if (!strcmp(key, "Name")) { - if (!edbus_message_iter_arguments_get(variant, "s", &name)) + if (!eldbus_message_iter_arguments_get(variant, "s", &name)) return; } else if (!strcmp(key, "Discoverable")) { - if (!edbus_message_iter_arguments_get(variant, "b", &visible)) + if (!eldbus_message_iter_arguments_get(variant, "b", &visible)) return; } else if (!strcmp(key, "Pairable")) { - if (!edbus_message_iter_arguments_get(variant, "b", &pairable)) + if (!eldbus_message_iter_arguments_get(variant, "b", &pairable)) return; } else if (!strcmp(key, "Powered")) { - if (!edbus_message_iter_arguments_get(variant, "b", &powered)) + if (!eldbus_message_iter_arguments_get(variant, "b", &powered)) return; } } @@ -545,12 +545,12 @@ _on_adap_properties(void *data, const EDBus_Message *msg, EDBus_Pending *pending static void _unset_default_adapter(void) { - DBG("Remove default adapter %s", edbus_object_path_get(ctxt->adap_obj)); + DBG("Remove default adapter %s", eldbus_object_path_get(ctxt->adap_obj)); _free_dev_list(&ctxt->devices); ctxt->devices = NULL; _free_dev_list(&ctxt->found_devices); ctxt->found_devices = NULL; - edbus_object_unref(ctxt->adap_obj); + eldbus_object_unref(ctxt->adap_obj); ctxt->adap_obj = NULL; ebluez4_update_all_gadgets_visibility(); } @@ -564,7 +564,7 @@ _unset_adapter(const char *path) if (!adap) return; - if (!strcmp(edbus_object_path_get(ctxt->adap_obj), path)) + if (!strcmp(eldbus_object_path_get(ctxt->adap_obj), path)) _unset_default_adapter(); ctxt->adapters = eina_list_remove(ctxt->adapters, adap); _free_adap(adap); @@ -576,45 +576,45 @@ _set_adapter(const char *path) { Adapter *adap = calloc(1, sizeof(Adapter)); - adap->obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, path); + adap->obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, path); if (ctxt->adap_obj && adap->obj == ctxt->adap_obj) adap->is_default = EINA_TRUE; else adap->is_default = EINA_FALSE; - adap->proxy = edbus_proxy_get(adap->obj, ADAPTER_INTERFACE); - edbus_proxy_call(adap->proxy, "GetProperties", _on_adap_properties, adap, -1, + adap->proxy = eldbus_proxy_get(adap->obj, ADAPTER_INTERFACE); + eldbus_proxy_call(adap->proxy, "GetProperties", _on_adap_properties, adap, -1, ""); - edbus_proxy_signal_handler_add(adap->proxy, "PropertyChanged", + eldbus_proxy_signal_handler_add(adap->proxy, "PropertyChanged", _on_adap_property_changed, adap); ctxt->adapters = eina_list_append(ctxt->adapters, adap); } static void -_on_list_adapters(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_on_list_adapters(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; const char *path; const char *err_msg = "Error reading list of adapters"; - if (!edbus_message_arguments_get(msg, "ao", &array)) + if (!eldbus_message_arguments_get(msg, "ao", &array)) { ERR("%s", err_msg); ebluez4_show_error("Bluez Error", err_msg); return; } - while (edbus_message_iter_get_and_next(array, 'o', &path)) + while (eldbus_message_iter_get_and_next(array, 'o', &path)) _set_adapter(path); } static void -_set_default_adapter(const EDBus_Message *msg) +_set_default_adapter(const Eldbus_Message *msg) { Adapter *adap; const char *adap_path; const char *err_msg = "Error reading path of Default Adapter"; - if (!edbus_message_arguments_get(msg, "o", &adap_path)) + if (!eldbus_message_arguments_get(msg, "o", &adap_path)) { ERR("%s", err_msg); ebluez4_show_error("Bluez Error", err_msg); @@ -630,24 +630,24 @@ _set_default_adapter(const EDBus_Message *msg) if (adap) adap->is_default = EINA_TRUE; - ctxt->adap_obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, adap_path); - ctxt->adap_proxy = edbus_proxy_get(ctxt->adap_obj, ADAPTER_INTERFACE); + ctxt->adap_obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, adap_path); + ctxt->adap_proxy = eldbus_proxy_get(ctxt->adap_obj, ADAPTER_INTERFACE); - edbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceFound", + eldbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceFound", _on_device_found, NULL); - edbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceCreated", + eldbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceCreated", _on_created, NULL); - edbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceRemoved", + eldbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceRemoved", _on_removed, NULL); - edbus_proxy_call(ctxt->adap_proxy, "ListDevices", _on_list_devices, NULL, -1, + eldbus_proxy_call(ctxt->adap_proxy, "ListDevices", _on_list_devices, NULL, -1, ""); - edbus_proxy_call(ctxt->adap_proxy, "RegisterAgent", NULL, NULL, -1, "os", + eldbus_proxy_call(ctxt->adap_proxy, "RegisterAgent", NULL, NULL, -1, "os", REMOTE_AGENT_PATH, "KeyboardDisplay"); ebluez4_update_all_gadgets_visibility(); } static void -_default_adapter_get(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +_default_adapter_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { const char *err_name, *err_msg; @@ -655,7 +655,7 @@ _default_adapter_get(void *data, const EDBus_Message *msg, EDBus_Pending *pendin * If bluetoothd is starting up, we can fail here and wait for the * DefaultAdapterChanged signal later */ - if (edbus_message_error_get(msg, &err_name, &err_msg)) + if (eldbus_message_error_get(msg, &err_name, &err_msg)) return; if (!ctxt->adap_obj) @@ -663,18 +663,18 @@ _default_adapter_get(void *data, const EDBus_Message *msg, EDBus_Pending *pendin } static void -_on_default_adapter_changed(void *context, const EDBus_Message *msg) +_on_default_adapter_changed(void *context, const Eldbus_Message *msg) { _set_default_adapter(msg); } static void -_on_adapter_removed(void *context, const EDBus_Message *msg) +_on_adapter_removed(void *context, const Eldbus_Message *msg) { const char *adap_path; const char *err_msg = "Error reading path of Removed Adapter"; - if (!edbus_message_arguments_get(msg, "o", &adap_path)) + if (!eldbus_message_arguments_get(msg, "o", &adap_path)) { ERR("%s", err_msg); ebluez4_show_error("Bluez Error", err_msg); @@ -685,12 +685,12 @@ _on_adapter_removed(void *context, const EDBus_Message *msg) } static void -_on_adapter_added(void *context, const EDBus_Message *msg) +_on_adapter_added(void *context, const Eldbus_Message *msg) { const char *adap_path; const char *err_msg = "Error reading path of Added Adapter"; - if (!edbus_message_arguments_get(msg, "o", &adap_path)) + if (!eldbus_message_arguments_get(msg, "o", &adap_path)) { ERR("%s", err_msg); ebluez4_show_error("Bluez Error", err_msg); @@ -706,9 +706,9 @@ _bluez_monitor(void *data, const char *bus, const char *old_id, const char *new_ if (!strcmp(old_id,"") && strcmp(new_id,"")) { // Bluez up - edbus_proxy_call(ctxt->man_proxy, "DefaultAdapter", + eldbus_proxy_call(ctxt->man_proxy, "DefaultAdapter", _default_adapter_get, NULL, -1, ""); - edbus_proxy_call(ctxt->man_proxy, "ListAdapters", + eldbus_proxy_call(ctxt->man_proxy, "ListAdapters", _on_list_adapters, NULL, -1, ""); } else if (strcmp(old_id,"") && !strcmp(new_id,"")) @@ -721,42 +721,42 @@ _bluez_monitor(void *data, const char *bus, const char *old_id, const char *new_ /* Public Functions */ void -ebluez4_edbus_init(void) +ebluez4_eldbus_init(void) { - EDBus_Object *obj; + Eldbus_Object *obj; ctxt = calloc(1, sizeof(Context)); - edbus_init(); + eldbus_init(); - ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); - obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, MANAGER_PATH); - ctxt->man_proxy = edbus_proxy_get(obj, MANAGER_INTERFACE); + ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); + obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, MANAGER_PATH); + ctxt->man_proxy = eldbus_proxy_get(obj, MANAGER_INTERFACE); ebluez4_register_agent_interfaces(ctxt->conn); - edbus_proxy_signal_handler_add(ctxt->man_proxy, "DefaultAdapterChanged", + eldbus_proxy_signal_handler_add(ctxt->man_proxy, "DefaultAdapterChanged", _on_default_adapter_changed, NULL); - edbus_proxy_signal_handler_add(ctxt->man_proxy, "AdapterRemoved", + eldbus_proxy_signal_handler_add(ctxt->man_proxy, "AdapterRemoved", _on_adapter_removed, NULL); - edbus_proxy_signal_handler_add(ctxt->man_proxy, "AdapterAdded", + eldbus_proxy_signal_handler_add(ctxt->man_proxy, "AdapterAdded", _on_adapter_added, NULL); - edbus_name_owner_changed_callback_add(ctxt->conn, BLUEZ_BUS, _bluez_monitor, + eldbus_name_owner_changed_callback_add(ctxt->conn, BLUEZ_BUS, _bluez_monitor, NULL, EINA_TRUE); } void -ebluez4_edbus_shutdown(void) +ebluez4_eldbus_shutdown(void) { if (ctxt->adap_obj) _unset_default_adapter(); _free_adap_list(); - edbus_object_unref(edbus_proxy_object_get(ctxt->man_proxy)); - edbus_connection_unref(ctxt->conn); + eldbus_object_unref(eldbus_proxy_object_get(ctxt->man_proxy)); + eldbus_connection_unref(ctxt->conn); free(ctxt); - edbus_shutdown(); + eldbus_shutdown(); } void @@ -764,13 +764,13 @@ ebluez4_start_discovery(void) { _free_dev_list(&ctxt->found_devices); ebluez4_update_instances(ctxt->found_devices); - edbus_proxy_call(ctxt->adap_proxy, "StartDiscovery", NULL, NULL, -1, ""); + eldbus_proxy_call(ctxt->adap_proxy, "StartDiscovery", NULL, NULL, -1, ""); } void ebluez4_stop_discovery(void) { - edbus_proxy_call(ctxt->adap_proxy, "StopDiscovery", NULL, NULL, -1, ""); + eldbus_proxy_call(ctxt->adap_proxy, "StopDiscovery", NULL, NULL, -1, ""); } void @@ -796,15 +796,15 @@ ebluez4_pair_with_device(const char *addr, void (*cb)(void *, Eina_Bool, const c EINA_SAFETY_ON_NULL_RETURN(d); d->cb = cb; d->data = data; - edbus_proxy_call(ctxt->adap_proxy, "CreatePairedDevice", _on_paired, d, + eldbus_proxy_call(ctxt->adap_proxy, "CreatePairedDevice", _on_paired, d, -1, "sos", addr, AGENT_PATH, "KeyboardDisplay"); } void -ebluez4_remove_device(EDBus_Object *obj) +ebluez4_remove_device(Eldbus_Object *obj) { - edbus_proxy_call(ctxt->adap_proxy, "RemoveDevice", NULL, NULL, -1, "o", - edbus_object_path_get(obj)); + eldbus_proxy_call(ctxt->adap_proxy, "RemoveDevice", NULL, NULL, -1, "o", + eldbus_object_path_get(obj)); } int @@ -813,22 +813,22 @@ ebluez4_dev_path_cmp(const void *d1, const void *d2) const Device *dev = d1; const char *path = d2; - return strcmp(edbus_object_path_get(dev->obj), path); + return strcmp(eldbus_object_path_get(dev->obj), path); } void ebluez4_adapter_property_set(Adapter *adap, const char *prop_name, Eina_Bool value) { - EDBus_Message_Iter *variant, *iter; - EDBus_Message *new_msg; + Eldbus_Message_Iter *variant, *iter; + Eldbus_Message *new_msg; if (!adap) return; if (!adap->obj) return; - new_msg = edbus_proxy_method_call_new(adap->proxy, "SetProperty"); - iter = edbus_message_iter_get(new_msg); - edbus_message_iter_basic_append(iter, 's', prop_name); - variant = edbus_message_iter_container_new(iter, 'v', "b"); - edbus_message_iter_basic_append(variant, 'b', value); - edbus_message_iter_container_close(iter, variant); - edbus_proxy_send(adap->proxy, new_msg, NULL, NULL, -1); + new_msg = eldbus_proxy_method_call_new(adap->proxy, "SetProperty"); + iter = eldbus_message_iter_get(new_msg); + eldbus_message_iter_basic_append(iter, 's', prop_name); + variant = eldbus_message_iter_container_new(iter, 'v', "b"); + eldbus_message_iter_basic_append(variant, 'b', value); + eldbus_message_iter_container_close(iter, variant); + eldbus_proxy_send(adap->proxy, new_msg, NULL, NULL, -1); } diff --git a/src/modules/bluez4/ebluez4.h b/src/modules/bluez4/ebluez4.h index cf29eed3b..058defec0 100644 --- a/src/modules/bluez4/ebluez4.h +++ b/src/modules/bluez4/ebluez4.h @@ -1,4 +1,4 @@ -#include "EDBus.h" +#include "Eldbus.h" #define BLUEZ_BUS "org.bluez" #define MANAGER_PATH "/" @@ -34,13 +34,13 @@ typedef struct _Device const char *type; Eina_Bool paired; Eina_Bool connected; - EDBus_Object *obj; + Eldbus_Object *obj; struct { - EDBus_Proxy *dev; - EDBus_Proxy *input; - EDBus_Proxy *audio_sink; - EDBus_Proxy *audio_source; + Eldbus_Proxy *dev; + Eldbus_Proxy *input; + Eldbus_Proxy *audio_sink; + Eldbus_Proxy *audio_source; } proxy; } Device; @@ -55,16 +55,16 @@ typedef struct _Adapter int powered_checked; Eina_Bool is_default; E_Dialog *dialog; - EDBus_Object *obj; - EDBus_Proxy *proxy; + Eldbus_Object *obj; + Eldbus_Proxy *proxy; } Adapter; typedef struct _Context { - EDBus_Connection *conn; - EDBus_Object *adap_obj; - EDBus_Proxy *man_proxy; - EDBus_Proxy *adap_proxy; + Eldbus_Connection *conn; + Eldbus_Object *adap_obj; + Eldbus_Proxy *man_proxy; + Eldbus_Proxy *adap_proxy; Eina_List *devices; Eina_List *found_devices; Eina_List *adapters; @@ -72,13 +72,13 @@ typedef struct _Context Context *ctxt; -void ebluez4_edbus_init(void); -void ebluez4_edbus_shutdown(void); +void ebluez4_eldbus_init(void); +void ebluez4_eldbus_shutdown(void); void ebluez4_start_discovery(void); void ebluez4_stop_discovery(void); void ebluez4_connect_to_device(Device *dev); void ebluez4_disconnect_device(Device *dev); void ebluez4_pair_with_device(const char *addr, void (*cb)(void *, Eina_Bool, const char *), void *data); -void ebluez4_remove_device(EDBus_Object *obj); +void ebluez4_remove_device(Eldbus_Object *obj); int ebluez4_dev_path_cmp(const void *d1, const void *d2); void ebluez4_adapter_property_set(Adapter *adap, const char *prop_name, Eina_Bool value); diff --git a/src/modules/connman/E_Connman.h b/src/modules/connman/E_Connman.h index f249da93d..272233b9f 100644 --- a/src/modules/connman/E_Connman.h +++ b/src/modules/connman/E_Connman.h @@ -3,7 +3,7 @@ #include "e.h" #include -#include +#include typedef struct _E_Connman_Agent E_Connman_Agent; @@ -32,8 +32,8 @@ enum Connman_Service_Type struct Connman_Manager { const char *path; - EDBus_Proxy *technology_iface; - EDBus_Proxy *manager_iface; + Eldbus_Proxy *technology_iface; + Eldbus_Proxy *manager_iface; Eina_Inlist *services; /* The prioritized list of services */ @@ -45,16 +45,16 @@ struct Connman_Manager /* Private */ struct { - EDBus_Pending *get_services; - EDBus_Pending *get_wifi_properties; - EDBus_Pending *set_powered; + Eldbus_Pending *get_services; + Eldbus_Pending *get_wifi_properties; + Eldbus_Pending *set_powered; } pending; }; struct Connman_Service { const char *path; - EDBus_Proxy *service_iface; + Eldbus_Proxy *service_iface; EINA_INLIST; /* Properties */ @@ -67,8 +67,8 @@ struct Connman_Service /* Private */ struct { - EDBus_Pending *connect; - EDBus_Pending *disconnect; + Eldbus_Pending *connect; + Eldbus_Pending *disconnect; void *data; } pending; }; @@ -79,7 +79,7 @@ extern int E_CONNMAN_EVENT_MANAGER_OUT; /* Daemon monitoring */ -unsigned int e_connman_system_init(EDBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); +unsigned int e_connman_system_init(Eldbus_Connection *eldbus_conn) EINA_ARG_NONNULL(1); unsigned int e_connman_system_shutdown(void); /* Requests from UI */ diff --git a/src/modules/connman/agent.c b/src/modules/connman/agent.c index 1c1e68711..ea78c9445 100644 --- a/src/modules/connman/agent.c +++ b/src/modules/connman/agent.c @@ -34,23 +34,23 @@ struct _E_Connman_Agent_Input struct _E_Connman_Agent { E_Dialog *dialog; - EDBus_Service_Interface *iface; - EDBus_Message *msg; - EDBus_Connection *conn; + Eldbus_Service_Interface *iface; + Eldbus_Message *msg; + Eldbus_Connection *conn; Eina_Bool canceled:1; }; static void -_dict_append_basic(EDBus_Message_Iter *array, const char *key, void *val) +_dict_append_basic(Eldbus_Message_Iter *array, const char *key, void *val) { - EDBus_Message_Iter *dict, *variant; + Eldbus_Message_Iter *dict, *variant; - edbus_message_iter_arguments_append(array, "{sv}", &dict); - edbus_message_iter_basic_append(dict, 's', key); - variant = edbus_message_iter_container_new(dict, 'v', "s"); - edbus_message_iter_basic_append(variant, 's', val); - edbus_message_iter_container_close(dict, variant); - edbus_message_iter_container_close(array, dict); + eldbus_message_iter_arguments_append(array, "{sv}", &dict); + eldbus_message_iter_basic_append(dict, 's', key); + variant = eldbus_message_iter_container_new(dict, 'v', "s"); + eldbus_message_iter_basic_append(variant, 's', val); + eldbus_message_iter_container_close(dict, variant); + eldbus_message_iter_container_close(array, dict); } static void @@ -59,9 +59,9 @@ _dialog_ok_cb(void *data, E_Dialog *dialog) E_Connman_Agent *agent = data; E_Connman_Agent_Input *input; Evas_Object *toolbook, *list; - EDBus_Message_Iter *iter, *array; + Eldbus_Message_Iter *iter, *array; Eina_List *input_list, *l; - EDBus_Message *reply; + Eldbus_Message *reply; toolbook = agent->dialog->content_object; @@ -81,15 +81,15 @@ _dialog_ok_cb(void *data, E_Dialog *dialog) agent->canceled = EINA_FALSE; input_list = evas_object_data_get(list, "input_list"); - reply = edbus_message_method_return_new(agent->msg); - iter = edbus_message_iter_get(reply); - edbus_message_iter_arguments_append(iter, "a{sv}", &array); + reply = eldbus_message_method_return_new(agent->msg); + iter = eldbus_message_iter_get(reply); + eldbus_message_iter_arguments_append(iter, "a{sv}", &array); EINA_LIST_FOREACH(input_list, l, input) _dict_append_basic(array, input->key, input->value); - edbus_message_iter_container_close(iter, array); + eldbus_message_iter_container_close(iter, array); - edbus_connection_send(agent->conn, reply, NULL, NULL, -1); + eldbus_connection_send(agent->conn, reply, NULL, NULL, -1); e_object_del(E_OBJECT(dialog)); } @@ -118,12 +118,12 @@ _dialog_key_down_cb(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, static void _dialog_cancel(E_Connman_Agent *agent) { - EDBus_Message *reply; + Eldbus_Message *reply; - reply = edbus_message_error_new(agent->msg, + reply = eldbus_message_error_new(agent->msg, "net.connman.Agent.Error.Canceled", "User canceled dialog"); - edbus_connection_send(agent->conn, reply, NULL, NULL, -1); + eldbus_connection_send(agent->conn, reply, NULL, NULL, -1); } static void @@ -136,7 +136,7 @@ _dialog_del_cb(void *data) _dialog_cancel(agent); // FIXME need to mark cs->pending_connect = NULL; - edbus_message_unref(agent->msg); + eldbus_message_unref(agent->msg); agent->dialog = NULL; } @@ -277,18 +277,18 @@ _dialog_new(E_Connman_Agent *agent) return dialog; } -static EDBus_Message * -_agent_release(const EDBus_Service_Interface *iface, - const EDBus_Message *msg) +static Eldbus_Message * +_agent_release(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg) { E_Connman_Agent *agent; - EDBus_Message *reply; + Eldbus_Message *reply; DBG("Agent released"); - reply = edbus_message_method_return_new(msg); + reply = eldbus_message_method_return_new(msg); - agent = edbus_service_object_data_get(iface, AGENT_KEY); + agent = eldbus_service_object_data_get(iface, AGENT_KEY); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply); if (agent->dialog) @@ -297,35 +297,35 @@ _agent_release(const EDBus_Service_Interface *iface, return reply; } -static EDBus_Message * -_agent_report_error(const EDBus_Service_Interface *iface, - const EDBus_Message *msg) +static Eldbus_Message * +_agent_report_error(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg) { return NULL; } -static EDBus_Message * -_agent_request_browser(const EDBus_Service_Interface *iface, - const EDBus_Message *msg) +static Eldbus_Message * +_agent_request_browser(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg) { return NULL; } static Eina_Bool _parse_field_value(struct Connman_Field *field, const char *key, - EDBus_Message_Iter *value, const char *signature) + Eldbus_Message_Iter *value, const char *signature) { if (!strcmp(key, "Type")) { EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); - edbus_message_iter_basic_get(value, &field->type); + eldbus_message_iter_basic_get(value, &field->type); return EINA_TRUE; } if (!strcmp(key, "Requirement")) { EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); - edbus_message_iter_basic_get(value, &field->requirement); + eldbus_message_iter_basic_get(value, &field->requirement); return EINA_TRUE; } @@ -339,7 +339,7 @@ _parse_field_value(struct Connman_Field *field, const char *key, if (!strcmp(key, "Value")) { EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); - edbus_message_iter_basic_get(value, &field->value); + eldbus_message_iter_basic_get(value, &field->value); return EINA_TRUE; } @@ -348,23 +348,23 @@ _parse_field_value(struct Connman_Field *field, const char *key, } static Eina_Bool -_parse_field(struct Connman_Field *field, EDBus_Message_Iter *value, +_parse_field(struct Connman_Field *field, Eldbus_Message_Iter *value, const char *signature) { - EDBus_Message_Iter *array, *dict; + Eldbus_Message_Iter *array, *dict; - edbus_message_iter_arguments_get(value, "a{sv}", &array); + eldbus_message_iter_arguments_get(value, "a{sv}", &array); EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE); - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *key; char *sig2; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var)) return EINA_FALSE; - sig2 = edbus_message_iter_signature_get(var); + sig2 = eldbus_message_iter_signature_get(var); if (!sig2) return EINA_FALSE; @@ -379,26 +379,26 @@ _parse_field(struct Connman_Field *field, EDBus_Message_Iter *value, return EINA_TRUE; } -static EDBus_Message * -_agent_request_input(const EDBus_Service_Interface *iface, - const EDBus_Message *msg) +static Eldbus_Message * +_agent_request_input(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg) { E_Connman_Module_Context *ctxt = connman_mod->data; const Eina_List *l; E_Connman_Instance *inst; - EDBus_Message_Iter *array, *dict; + Eldbus_Message_Iter *array, *dict; E_Connman_Agent *agent; const char *path; - agent = edbus_service_object_data_get(iface, AGENT_KEY); + agent = eldbus_service_object_data_get(iface, AGENT_KEY); /* Discard previous requests */ // if msg is the current agent msg? eek. if (agent->msg == msg) return NULL; if (agent->msg) - edbus_message_unref(agent->msg); - agent->msg = edbus_message_ref((EDBus_Message *)msg); + eldbus_message_unref(agent->msg); + agent->msg = eldbus_message_ref((Eldbus_Message *)msg); EINA_LIST_FOREACH(ctxt->instances, l, inst) econnman_popup_del(inst); @@ -408,18 +408,18 @@ _agent_request_input(const EDBus_Service_Interface *iface, agent->dialog = _dialog_new(agent); EINA_SAFETY_ON_NULL_GOTO(agent->dialog, err); - if (!edbus_message_arguments_get(msg, "oa{sv}", &path, &array)) + if (!eldbus_message_arguments_get(msg, "oa{sv}", &path, &array)) goto err; - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; char *signature; struct Connman_Field field = { NULL, NULL, NULL, NULL, NULL }; - if (!edbus_message_iter_arguments_get(dict, "sv", &field.name, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &field.name, &var)) goto err; - signature = edbus_message_iter_signature_get(var); + signature = eldbus_message_iter_signature_get(var); if (!signature) goto err; if (!_parse_field(&field, var, signature)) @@ -443,22 +443,22 @@ _agent_request_input(const EDBus_Service_Interface *iface, return NULL; err: - edbus_message_unref((EDBus_Message *)msg); + eldbus_message_unref((Eldbus_Message *)msg); agent->msg = NULL; WRN("Failed to parse msg"); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -_agent_cancel(const EDBus_Service_Interface *iface, - const EDBus_Message *msg) +static Eldbus_Message * +_agent_cancel(const Eldbus_Service_Interface *iface, + const Eldbus_Message *msg) { E_Connman_Agent *agent; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); DBG("Agent canceled"); - agent = edbus_service_object_data_get(iface, AGENT_KEY); + agent = eldbus_service_object_data_get(iface, AGENT_KEY); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply); if (agent->dialog) @@ -467,48 +467,48 @@ _agent_cancel(const EDBus_Service_Interface *iface, return reply; } -static const EDBus_Method methods[] = { +static const Eldbus_Method methods[] = { { "Release", NULL, NULL, _agent_release, 0 }, { - "ReportError", EDBUS_ARGS({"o", "service"}, {"s", "error"}), NULL, + "ReportError", ELDBUS_ARGS({"o", "service"}, {"s", "error"}), NULL, _agent_report_error, 0 }, { - "RequestBrowser", EDBUS_ARGS({"o", "service"}, {"s", "url"}), NULL, + "RequestBrowser", ELDBUS_ARGS({"o", "service"}, {"s", "url"}), NULL, _agent_request_browser, 0 }, { - "RequestInput", EDBUS_ARGS({"o", "service"}, {"a{sv}", "fields"}), - EDBUS_ARGS({"a{sv}", ""}), _agent_request_input, 0 + "RequestInput", ELDBUS_ARGS({"o", "service"}, {"a{sv}", "fields"}), + ELDBUS_ARGS({"a{sv}", ""}), _agent_request_input, 0 }, { "Cancel", NULL, NULL, _agent_cancel, 0 }, { NULL, NULL, NULL, NULL, 0 } }; -static const EDBus_Service_Interface_Desc desc = { +static const Eldbus_Service_Interface_Desc desc = { AGENT_IFACE, methods, NULL, NULL, NULL, NULL }; E_Connman_Agent * -econnman_agent_new(EDBus_Connection *edbus_conn) +econnman_agent_new(Eldbus_Connection *eldbus_conn) { - EDBus_Service_Interface *iface; + Eldbus_Service_Interface *iface; E_Connman_Agent *agent; agent = E_NEW(E_Connman_Agent, 1); EINA_SAFETY_ON_NULL_RETURN_VAL(agent, NULL); - iface = edbus_service_interface_register(edbus_conn, AGENT_PATH, &desc); + iface = eldbus_service_interface_register(eldbus_conn, AGENT_PATH, &desc); if (!iface) { - ERR("Failed to create edbus interface"); + ERR("Failed to create eldbus interface"); free(agent); return NULL; } - edbus_service_object_data_set(iface, AGENT_KEY, agent); + eldbus_service_object_data_set(iface, AGENT_KEY, agent); agent->iface = iface; - agent->conn = edbus_conn; + agent->conn = eldbus_conn; return agent; } @@ -517,6 +517,6 @@ void econnman_agent_del(E_Connman_Agent *agent) { EINA_SAFETY_ON_NULL_RETURN(agent); - edbus_service_object_unregister(agent->iface); + eldbus_service_object_unregister(agent->iface); free(agent); } diff --git a/src/modules/connman/e_connman.c b/src/modules/connman/e_connman.c index 6f7cfe8de..29649a904 100644 --- a/src/modules/connman/e_connman.c +++ b/src/modules/connman/e_connman.c @@ -9,7 +9,7 @@ #define CONNMAN_CONNECTION_TIMEOUT 60 * MILLI_PER_SEC static unsigned int init_count; -static EDBus_Connection *conn; +static Eldbus_Connection *conn; static struct Connman_Manager *connman_manager; static E_Connman_Agent *agent; @@ -30,16 +30,16 @@ static void _eina_str_array_clean(Eina_Array *array) eina_array_clean(array); } -static void _dbus_str_array_to_eina(EDBus_Message_Iter *value, Eina_Array **old, +static void _dbus_str_array_to_eina(Eldbus_Message_Iter *value, Eina_Array **old, unsigned nelem) { - EDBus_Message_Iter *itr_array; + Eldbus_Message_Iter *itr_array; Eina_Array *array; const char *s; EINA_SAFETY_ON_NULL_RETURN(value); EINA_SAFETY_ON_NULL_RETURN(old); - EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, "as", + EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "as", &itr_array)); array = *old; @@ -51,7 +51,7 @@ static void _dbus_str_array_to_eina(EDBus_Message_Iter *value, Eina_Array **old, else _eina_str_array_clean(array); - while (edbus_message_iter_get_and_next(itr_array, 's', &s)) + while (eldbus_message_iter_get_and_next(itr_array, 's', &s)) { eina_array_push(array, eina_stringshare_add(s)); DBG("Push %s", s); @@ -148,14 +148,14 @@ const char *econnman_service_type_to_str(enum Connman_Service_Type type) static void _service_parse_prop_changed(struct Connman_Service *cs, const char *prop_name, - EDBus_Message_Iter *value) + Eldbus_Message_Iter *value) { DBG("service %p %s prop %s", cs, cs->path, prop_name); if (strcmp(prop_name, "State") == 0) { const char *state; - EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "s", &state)); cs->state = str_to_state(state); @@ -164,7 +164,7 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, else if (strcmp(prop_name, "Name") == 0) { const char *name; - EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "s", &name)); free(cs->name); @@ -174,7 +174,7 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, else if (strcmp(prop_name, "Type") == 0) { const char *type; - EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "s", &type)); cs->type = str_to_type(type); @@ -183,7 +183,7 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, else if (strcmp(prop_name, "Strength") == 0) { uint8_t strength; - EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "y", &strength)); cs->strength = strength; @@ -199,27 +199,27 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, } static void _service_prop_dict_changed(struct Connman_Service *cs, - EDBus_Message_Iter *props) + Eldbus_Message_Iter *props) { - EDBus_Message_Iter *dict; - while (edbus_message_iter_get_and_next(props, 'e', &dict)) + Eldbus_Message_Iter *dict; + while (eldbus_message_iter_get_and_next(props, 'e', &dict)) { char *name; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; - if (!edbus_message_iter_arguments_get(dict, "sv", &name, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &name, &var)) continue; _service_parse_prop_changed(cs, name, var); } } -static void _service_prop_changed(void *data, const EDBus_Message *msg) +static void _service_prop_changed(void *data, const Eldbus_Message *msg) { struct Connman_Service *cs = data; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *name; - if (!edbus_message_arguments_get(msg, "sv", &name, &var)) + if (!eldbus_message_arguments_get(msg, "sv", &name, &var)) return; _service_parse_prop_changed(cs, name, var); @@ -233,18 +233,18 @@ struct connection_data { static void _service_free(struct Connman_Service *cs) { - EDBus_Object *obj; + Eldbus_Object *obj; if (!cs) return; if (cs->pending.connect) { - edbus_pending_cancel(cs->pending.connect); + eldbus_pending_cancel(cs->pending.connect); free(cs->pending.data); } if (cs->pending.disconnect) { - edbus_pending_cancel(cs->pending.disconnect); + eldbus_pending_cancel(cs->pending.disconnect); free(cs->pending.data); } @@ -252,17 +252,17 @@ static void _service_free(struct Connman_Service *cs) _eina_str_array_clean(cs->security); eina_array_free(cs->security); eina_stringshare_del(cs->path); - obj = edbus_proxy_object_get(cs->service_iface); - edbus_proxy_unref(cs->service_iface); - edbus_object_unref(obj); + obj = eldbus_proxy_object_get(cs->service_iface); + eldbus_proxy_unref(cs->service_iface); + eldbus_object_unref(obj); free(cs); } -static struct Connman_Service *_service_new(const char *path, EDBus_Message_Iter *props) +static struct Connman_Service *_service_new(const char *path, Eldbus_Message_Iter *props) { struct Connman_Service *cs; - EDBus_Object *obj; + Eldbus_Object *obj; EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL); @@ -271,24 +271,24 @@ static struct Connman_Service *_service_new(const char *path, EDBus_Message_Iter cs->path = eina_stringshare_add(path); - obj = edbus_object_get(conn, CONNMAN_BUS_NAME, path); - cs->service_iface = edbus_proxy_get(obj, CONNMAN_SERVICE_IFACE); - edbus_proxy_signal_handler_add(cs->service_iface, "PropertyChanged", + obj = eldbus_object_get(conn, CONNMAN_BUS_NAME, path); + cs->service_iface = eldbus_proxy_get(obj, CONNMAN_SERVICE_IFACE); + eldbus_proxy_signal_handler_add(cs->service_iface, "PropertyChanged", _service_prop_changed, cs); _service_prop_dict_changed(cs, props); return cs; } -static void _service_connection_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +static void _service_connection_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { struct connection_data *cd = data; if (cd->cb) { const char *s = NULL; - edbus_message_error_get(msg, NULL, &s); + eldbus_message_error_get(msg, NULL, &s); cd->cb(cd->user_data, s); } @@ -320,7 +320,7 @@ bool econnman_service_connect(struct Connman_Service *cs, cd->cb = cb; cd->user_data = data; - cs->pending.connect = edbus_proxy_call(cs->service_iface, "Connect", + cs->pending.connect = eldbus_proxy_call(cs->service_iface, "Connect", _service_connection_cb, cd, CONNMAN_CONNECTION_TIMEOUT, ""); return true; @@ -350,7 +350,7 @@ bool econnman_service_disconnect(struct Connman_Service *cs, cd->cb = cb; cd->user_data = data; - cs->pending.connect = edbus_proxy_call(cs->service_iface, "Disconnect", + cs->pending.connect = eldbus_proxy_call(cs->service_iface, "Disconnect", _service_connection_cb, cd, -1, ""); return true; @@ -387,10 +387,10 @@ struct Connman_Service *econnman_manager_find_service(struct Connman_Manager *cm } static void _manager_services_remove(struct Connman_Manager *cm, - EDBus_Message_Iter *array) + Eldbus_Message_Iter *array) { const char *path; - while (edbus_message_iter_get_and_next(array, 'o', &path)) + while (eldbus_message_iter_get_and_next(array, 'o', &path)) { struct Connman_Service *cs; cs = econnman_manager_find_service(cm, path); @@ -406,16 +406,16 @@ static void _manager_services_remove(struct Connman_Manager *cm, } } -static void _manager_services_changed(void *data, const EDBus_Message *msg) +static void _manager_services_changed(void *data, const Eldbus_Message *msg) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *changed, *removed, *s; + Eldbus_Message_Iter *changed, *removed, *s; Eina_Inlist *tmp = NULL; if (cm->pending.get_services) return; - if (!edbus_message_arguments_get(msg, "a(oa{sv})ao", &changed, &removed)) + if (!eldbus_message_arguments_get(msg, "a(oa{sv})ao", &changed, &removed)) { ERR("Error getting arguments"); return; @@ -423,13 +423,13 @@ static void _manager_services_changed(void *data, const EDBus_Message *msg) _manager_services_remove(cm, removed); - while (edbus_message_iter_get_and_next(changed, 'r', &s)) + while (eldbus_message_iter_get_and_next(changed, 'r', &s)) { struct Connman_Service *cs; const char *path; - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; - if (!edbus_message_iter_arguments_get(s, "oa{sv}", &path, &array)) + if (!eldbus_message_iter_arguments_get(s, "oa{sv}", &path, &array)) continue; cs = econnman_manager_find_service(cm, path); @@ -452,35 +452,35 @@ static void _manager_services_changed(void *data, const EDBus_Message *msg) econnman_mod_services_changed(cm); } -static void _manager_get_services_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +static void _manager_get_services_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *array, *s; + Eldbus_Message_Iter *array, *s; const char *name, *text; cm->pending.get_services = NULL; - if (edbus_message_error_get(msg, &name, &text)) + if (eldbus_message_error_get(msg, &name, &text)) { ERR("Could not get services. %s: %s", name, text); return; } DBG("cm->services=%p", cm->services); - if (!edbus_message_arguments_get(msg, "a(oa{sv})", &array)) + if (!eldbus_message_arguments_get(msg, "a(oa{sv})", &array)) { ERR("Error getting array"); return; } - while (edbus_message_iter_get_and_next(array, 'r', &s)) + while (eldbus_message_iter_get_and_next(array, 'r', &s)) { struct Connman_Service *cs; const char *path; - EDBus_Message_Iter *inner_array; + Eldbus_Message_Iter *inner_array; - if (!edbus_message_iter_arguments_get(s, "oa{sv}", &path, &inner_array)) + if (!eldbus_message_iter_arguments_get(s, "oa{sv}", &path, &inner_array)) continue; cs = _service_new(path, inner_array); @@ -495,19 +495,19 @@ static void _manager_get_services_cb(void *data, const EDBus_Message *msg, static bool _manager_parse_prop_changed(struct Connman_Manager *cm, const char *name, - EDBus_Message_Iter *value) + Eldbus_Message_Iter *value) { if (strcmp(name, "State") == 0) { const char *state; - if (!edbus_message_iter_arguments_get(value, "s", &state)) + if (!eldbus_message_iter_arguments_get(value, "s", &state)) return false; DBG("New state: %s", state); cm->state = str_to_state(state); } else if (strcmp(name, "OfflineMode") == 0) { - if (!edbus_message_iter_arguments_get(value, "b", &cm->offline_mode)) + if (!eldbus_message_iter_arguments_get(value, "b", &cm->offline_mode)) return false; } else @@ -518,13 +518,13 @@ static bool _manager_parse_prop_changed(struct Connman_Manager *cm, } static void -_manager_prop_changed(void *data, const EDBus_Message *msg) +_manager_prop_changed(void *data, const Eldbus_Message *msg) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *name; - if (!edbus_message_arguments_get(msg, "sv", &name, &var)) + if (!eldbus_message_arguments_get(msg, "sv", &name, &var)) { ERR("Could not parse message %p", msg); return; @@ -533,31 +533,31 @@ _manager_prop_changed(void *data, const EDBus_Message *msg) _manager_parse_prop_changed(cm, name, var); } -static void _manager_get_prop_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +static void _manager_get_prop_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *array, *dict; + Eldbus_Message_Iter *array, *dict; const char *name, *text; - if (edbus_message_error_get(msg, &name, &text)) + if (eldbus_message_error_get(msg, &name, &text)) { ERR("Could not get properties. %s: %s", name, text); return; } - if (!edbus_message_arguments_get(msg, "a{sv}", &array)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &array)) { ERR("Error getting arguments."); return; } - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { const char *key; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var)) continue; _manager_parse_prop_changed(cm, key, var); } @@ -565,10 +565,10 @@ static void _manager_get_prop_cb(void *data, const EDBus_Message *msg, static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm, const char *name, - EDBus_Message_Iter *value) + Eldbus_Message_Iter *value) { if (!strcmp(name, "Powered")) - return edbus_message_iter_arguments_get(value, "b", &cm->powered); + return eldbus_message_iter_arguments_get(value, "b", &cm->powered); else return false; @@ -576,13 +576,13 @@ static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm, return true; } -static void _manager_wifi_prop_changed(void *data, const EDBus_Message *msg) +static void _manager_wifi_prop_changed(void *data, const Eldbus_Message *msg) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *name; - if (!edbus_message_arguments_get(msg, "sv", &name, &var)) + if (!eldbus_message_arguments_get(msg, "sv", &name, &var)) { ERR("Could not parse message %p", msg); return; @@ -591,33 +591,33 @@ static void _manager_wifi_prop_changed(void *data, const EDBus_Message *msg) _manager_parse_wifi_prop_changed(cm, name, var); } -static void _manager_get_wifi_prop_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +static void _manager_get_wifi_prop_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { struct Connman_Manager *cm = data; - EDBus_Message_Iter *array, *dict; + Eldbus_Message_Iter *array, *dict; const char *name, *message; cm->pending.get_wifi_properties = NULL; - if (edbus_message_error_get(msg, &name, &message)) + if (eldbus_message_error_get(msg, &name, &message)) { ERR("Could not get properties. %s: %s", name, message); return; } - if (!edbus_message_arguments_get(msg, "a{sv}", &array)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &array)) { ERR("Error getting arguments."); return; } - while (edbus_message_iter_get_and_next(array, 'e', &dict)) + while (eldbus_message_iter_get_and_next(array, 'e', &dict)) { - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *key; - if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var)) continue; _manager_parse_wifi_prop_changed(cm, key, var); } @@ -626,17 +626,17 @@ static void _manager_get_wifi_prop_cb(void *data, const EDBus_Message *msg, static void _manager_agent_unregister(struct Connman_Manager *cm) { - edbus_proxy_call(cm->manager_iface, "UnregisterAgent", NULL, NULL, -1, "o", + eldbus_proxy_call(cm->manager_iface, "UnregisterAgent", NULL, NULL, -1, "o", AGENT_PATH); } static void -_manager_agent_register_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +_manager_agent_register_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { const char *name, *text; - if (edbus_message_error_get(msg, &name, &text)) + if (eldbus_message_error_get(msg, &name, &text)) { WRN("Could not register agent. %s: %s", name, text); return; @@ -651,13 +651,13 @@ _manager_agent_register(struct Connman_Manager *cm) if (!cm) return; - edbus_proxy_call(cm->manager_iface, "RegisterAgent", + eldbus_proxy_call(cm->manager_iface, "RegisterAgent", _manager_agent_register_cb, NULL, -1, "o", AGENT_PATH); } static void _manager_free(struct Connman_Manager *cm) { - EDBus_Object *obj; + Eldbus_Object *obj; if (!cm) return; @@ -670,61 +670,61 @@ static void _manager_free(struct Connman_Manager *cm) } if (cm->pending.get_services) - edbus_pending_cancel(cm->pending.get_services); + eldbus_pending_cancel(cm->pending.get_services); if (cm->pending.get_wifi_properties) - edbus_pending_cancel(cm->pending.get_wifi_properties); + eldbus_pending_cancel(cm->pending.get_wifi_properties); if (cm->pending.set_powered) - edbus_pending_cancel(cm->pending.set_powered); + eldbus_pending_cancel(cm->pending.set_powered); eina_stringshare_del(cm->path); - obj = edbus_proxy_object_get(cm->manager_iface); - edbus_proxy_unref(cm->manager_iface); - edbus_object_unref(obj); - obj = edbus_proxy_object_get(cm->technology_iface); - edbus_proxy_unref(cm->technology_iface); - edbus_object_unref(obj); + obj = eldbus_proxy_object_get(cm->manager_iface); + eldbus_proxy_unref(cm->manager_iface); + eldbus_object_unref(obj); + obj = eldbus_proxy_object_get(cm->technology_iface); + eldbus_proxy_unref(cm->technology_iface); + eldbus_object_unref(obj); free(cm); } -static void _manager_powered_cb(void *data, const EDBus_Message *msg, - EDBus_Pending *pending) +static void _manager_powered_cb(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending) { - EDBus_Pending *p; + Eldbus_Pending *p; struct Connman_Manager *cm = data; const char *error_name, *error_msg; cm->pending.set_powered = NULL; - if (edbus_message_error_get(msg, &error_name, &error_msg)) + if (eldbus_message_error_get(msg, &error_name, &error_msg)) { ERR("Error: %s %s", error_name, error_msg); return; } if (cm->pending.get_wifi_properties) - edbus_pending_cancel(cm->pending.get_wifi_properties); - p = edbus_proxy_call(cm->technology_iface, "GetProperties", + eldbus_pending_cancel(cm->pending.get_wifi_properties); + p = eldbus_proxy_call(cm->technology_iface, "GetProperties", _manager_get_wifi_prop_cb, cm, -1, ""); cm->pending.get_wifi_properties = p; } void econnman_powered_set(struct Connman_Manager *cm, Eina_Bool powered) { - EDBus_Message_Iter *main_iter, *var; - EDBus_Message *msg; + Eldbus_Message_Iter *main_iter, *var; + Eldbus_Message *msg; if (cm->pending.set_powered) - edbus_pending_cancel(cm->pending.set_powered); + eldbus_pending_cancel(cm->pending.set_powered); - msg = edbus_proxy_method_call_new(cm->technology_iface, "SetProperty"); - main_iter = edbus_message_iter_get(msg); - edbus_message_iter_basic_append(main_iter, 's', "Powered"); - var = edbus_message_iter_container_new(main_iter, 'v', "b"); - edbus_message_iter_basic_append(var, 'b', powered); - edbus_message_iter_container_close(main_iter, var); + msg = eldbus_proxy_method_call_new(cm->technology_iface, "SetProperty"); + main_iter = eldbus_message_iter_get(msg); + eldbus_message_iter_basic_append(main_iter, 's', "Powered"); + var = eldbus_message_iter_container_new(main_iter, 'v', "b"); + eldbus_message_iter_basic_append(var, 'b', powered); + eldbus_message_iter_container_close(main_iter, var); - cm->pending.set_powered = edbus_proxy_send(cm->technology_iface, msg, + cm->pending.set_powered = eldbus_proxy_send(cm->technology_iface, msg, _manager_powered_cb, cm, -1); } @@ -732,25 +732,25 @@ static struct Connman_Manager *_manager_new(void) { const char *path = "/"; struct Connman_Manager *cm; - EDBus_Object *obj; + Eldbus_Object *obj; cm = calloc(1, sizeof(*cm)); EINA_SAFETY_ON_NULL_RETURN_VAL(cm, NULL); - obj = edbus_object_get(conn, CONNMAN_BUS_NAME, "/"); - cm->manager_iface = edbus_proxy_get(obj, CONNMAN_MANAGER_IFACE); - obj = edbus_object_get(conn, CONNMAN_BUS_NAME, + obj = eldbus_object_get(conn, CONNMAN_BUS_NAME, "/"); + cm->manager_iface = eldbus_proxy_get(obj, CONNMAN_MANAGER_IFACE); + obj = eldbus_object_get(conn, CONNMAN_BUS_NAME, "/net/connman/technology/wifi"); - cm->technology_iface = edbus_proxy_get(obj, CONNMAN_TECHNOLOGY_IFACE); + cm->technology_iface = eldbus_proxy_get(obj, CONNMAN_TECHNOLOGY_IFACE); cm->path = eina_stringshare_add(path); - edbus_proxy_signal_handler_add(cm->manager_iface, "PropertyChanged", + eldbus_proxy_signal_handler_add(cm->manager_iface, "PropertyChanged", _manager_prop_changed, cm); - edbus_proxy_signal_handler_add(cm->manager_iface, "ServicesChanged", + eldbus_proxy_signal_handler_add(cm->manager_iface, "ServicesChanged", _manager_services_changed, cm); - edbus_proxy_signal_handler_add(cm->technology_iface, "PropertyChanged", + eldbus_proxy_signal_handler_add(cm->technology_iface, "PropertyChanged", _manager_wifi_prop_changed, cm); /* @@ -758,13 +758,13 @@ static struct Connman_Manager *_manager_new(void) * after ServicesChanged above. So we only add the handler later, in a per * service manner. */ - cm->pending.get_services = edbus_proxy_call(cm->manager_iface, + cm->pending.get_services = eldbus_proxy_call(cm->manager_iface, "GetServices", _manager_get_services_cb, cm, -1, ""); - edbus_proxy_call(cm->manager_iface, "GetProperties", _manager_get_prop_cb, cm, + eldbus_proxy_call(cm->manager_iface, "GetProperties", _manager_get_prop_cb, cm, -1, ""); - cm->pending.get_wifi_properties = edbus_proxy_call(cm->technology_iface, + cm->pending.get_wifi_properties = eldbus_proxy_call(cm->technology_iface, "GetProperties", _manager_get_wifi_prop_cb, cm, -1, ""); @@ -811,7 +811,7 @@ _e_connman_system_name_owner_changed(void *data, const char *bus, const char *fr * - E_CONNMAN_EVENT_MANAGER_OUT: issued when connman connection is lost. */ unsigned int -e_connman_system_init(EDBus_Connection *edbus_conn) +e_connman_system_init(Eldbus_Connection *eldbus_conn) { init_count++; @@ -821,11 +821,11 @@ e_connman_system_init(EDBus_Connection *edbus_conn) E_CONNMAN_EVENT_MANAGER_IN = ecore_event_type_new(); E_CONNMAN_EVENT_MANAGER_OUT = ecore_event_type_new(); - conn = edbus_conn; - edbus_name_owner_changed_callback_add(conn, CONNMAN_BUS_NAME, + conn = eldbus_conn; + eldbus_name_owner_changed_callback_add(conn, CONNMAN_BUS_NAME, _e_connman_system_name_owner_changed, NULL, EINA_TRUE); - agent = econnman_agent_new(edbus_conn); + agent = econnman_agent_new(eldbus_conn); return init_count; } @@ -849,14 +849,14 @@ e_connman_system_shutdown(void) if (init_count > 0) return init_count; - edbus_name_owner_changed_callback_del(conn, CONNMAN_BUS_NAME, + eldbus_name_owner_changed_callback_del(conn, CONNMAN_BUS_NAME, _e_connman_system_name_owner_changed, NULL); _e_connman_system_name_owner_exit(); if (agent) econnman_agent_del(agent); if (conn) - edbus_connection_unref(conn); + eldbus_connection_unref(conn); agent = NULL; conn = NULL; diff --git a/src/modules/connman/e_mod_main.c b/src/modules/connman/e_mod_main.c index 8cd25e939..be9d0a854 100644 --- a/src/modules/connman/e_mod_main.c +++ b/src/modules/connman/e_mod_main.c @@ -606,7 +606,7 @@ EAPI void * e_modapi_init(E_Module *m) { E_Connman_Module_Context *ctxt; - EDBus_Connection *c; + Eldbus_Connection *c; if (_e_connman_log_dom < 0) { @@ -622,8 +622,8 @@ e_modapi_init(E_Module *m) ctxt = E_NEW(E_Connman_Module_Context, 1); if (!ctxt) goto error_connman_context; - edbus_init(); - c = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); + eldbus_init(); + c = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); if (!c) goto error_dbus_bus_get; if (!e_connman_system_init(c)) @@ -638,7 +638,7 @@ e_modapi_init(E_Module *m) return ctxt; error_connman_system_init: - edbus_connection_unref(c); + eldbus_connection_unref(c); error_dbus_bus_get: E_FREE(ctxt); error_connman_context: @@ -670,7 +670,7 @@ e_modapi_shutdown(E_Module *m) return 0; e_connman_system_shutdown(); - edbus_shutdown(); + eldbus_shutdown(); _econnman_instances_free(ctxt); _econnman_configure_registry_unregister(); diff --git a/src/modules/connman/e_mod_main.h b/src/modules/connman/e_mod_main.h index e3392755e..2f1338356 100644 --- a/src/modules/connman/e_mod_main.h +++ b/src/modules/connman/e_mod_main.h @@ -60,7 +60,7 @@ const char *e_connman_theme_path(void); E_Config_Dialog *e_connman_config_dialog_new(E_Container *con, E_Connman_Module_Context *ctxt); -E_Connman_Agent *econnman_agent_new(EDBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); +E_Connman_Agent *econnman_agent_new(Eldbus_Connection *eldbus_conn) EINA_ARG_NONNULL(1); void econnman_agent_del(E_Connman_Agent *agent); /** diff --git a/src/modules/fileman/e_mod_dbus.c b/src/modules/fileman/e_mod_dbus.c index 8fe72a3d1..28ad61ca5 100644 --- a/src/modules/fileman/e_mod_dbus.c +++ b/src/modules/fileman/e_mod_dbus.c @@ -8,36 +8,36 @@ static const char E_FILEMAN_PATH[] = "/org/enlightenment/FileManager"; typedef struct _E_Fileman_DBus_Daemon E_Fileman_DBus_Daemon; struct _E_Fileman_DBus_Daemon { - EDBus_Connection *conn; - EDBus_Service_Interface *iface; + Eldbus_Connection *conn; + Eldbus_Service_Interface *iface; }; -static EDBus_Message * _e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); -static EDBus_Message *_e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); +static Eldbus_Message * _e_fileman_dbus_daemon_open_directory_cb(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg); +static Eldbus_Message *_e_fileman_dbus_daemon_open_file_cb(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg); -static EDBus_Message * -_e_fileman_dbus_daemon_error(const EDBus_Message *msg, +static Eldbus_Message * +_e_fileman_dbus_daemon_error(const Eldbus_Message *msg, const char *error_msg) { - return edbus_message_error_new(msg, E_FILEMAN_ERROR, error_msg); + return eldbus_message_error_new(msg, E_FILEMAN_ERROR, error_msg); } -static const EDBus_Method methods[] = { - { "OpenDirectory", EDBUS_ARGS({"s", "directory"}), NULL, +static const Eldbus_Method methods[] = { + { "OpenDirectory", ELDBUS_ARGS({"s", "directory"}), NULL, _e_fileman_dbus_daemon_open_directory_cb }, - { "OpenFile", EDBUS_ARGS({"s", "file"}), NULL, + { "OpenFile", ELDBUS_ARGS({"s", "file"}), NULL, _e_fileman_dbus_daemon_open_file_cb }, { } }; -static const EDBus_Service_Interface_Desc desc = { +static const Eldbus_Service_Interface_Desc desc = { E_FILEMAN_INTERFACE, methods }; static void _e_fileman_dbus_daemon_object_init(E_Fileman_DBus_Daemon *d) { - d->iface = edbus_service_interface_register(d->conn, E_FILEMAN_PATH, &desc); + d->iface = eldbus_service_interface_register(d->conn, E_FILEMAN_PATH, &desc); if (!d->iface) { fprintf(stderr, "ERROR: cannot add object to %s\n", E_FILEMAN_PATH); @@ -49,25 +49,25 @@ static void _e_fileman_dbus_daemon_free(E_Fileman_DBus_Daemon *d) { if (d->iface) - edbus_service_object_unregister(d->iface); + eldbus_service_object_unregister(d->iface); if (d->conn) - edbus_connection_unref(d->conn); + eldbus_connection_unref(d->conn); free(d); } -static EDBus_Message * -_e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +_e_fileman_dbus_daemon_open_directory_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { const char *directory = NULL, *p; char *dev, *to_free = NULL; E_Zone *zone; - if (!edbus_message_arguments_get(msg, "s", &directory)) + if (!eldbus_message_arguments_get(msg, "s", &directory)) { fprintf(stderr, "Error: getting arguments of OpenDirectory call.\n"); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } if ((!directory) || (directory[0] == '\0')) @@ -123,7 +123,7 @@ _e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface __ e_fwin_new(zone->container, dev, directory); free(dev); free(to_free); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } static Eina_Bool @@ -150,19 +150,19 @@ _mime_shell_script_check(const char *mime) return EINA_FALSE; } -static EDBus_Message* -_e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message* +_e_fileman_dbus_daemon_open_file_cb(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { Eina_List *handlers; const char *param_file = NULL, *mime, *errmsg = "unknow error"; char *real_file, *to_free = NULL; E_Zone *zone; - if (!edbus_message_arguments_get(msg, "s", ¶m_file)) + if (!eldbus_message_arguments_get(msg, "s", ¶m_file)) { fprintf(stderr, "ERROR: getting arguments of OpenFile call.\n"); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } if ((!param_file) || (param_file[0] == '\0')) @@ -270,7 +270,7 @@ _e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface __UNUSE end: free(real_file); free(to_free); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); error: free(real_file); @@ -290,13 +290,13 @@ _e_fileman_dbus_daemon_new(void) return NULL; } - d->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + d->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); if (!d->conn) goto error; _e_fileman_dbus_daemon_object_init(d); - edbus_name_request(d->conn, E_FILEMAN_BUS_NAME, - EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); + eldbus_name_request(d->conn, E_FILEMAN_BUS_NAME, + ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); return d; error: @@ -313,7 +313,7 @@ e_fileman_dbus_init(void) if (_daemon) return; - edbus_init(); + eldbus_init(); _daemon = _e_fileman_dbus_daemon_new(); } @@ -325,6 +325,6 @@ e_fileman_dbus_shutdown(void) _e_fileman_dbus_daemon_free(_daemon); _daemon = NULL; - edbus_shutdown(); + eldbus_shutdown(); } diff --git a/src/modules/mixer/sys_pulse.c b/src/modules/mixer/sys_pulse.c index d21c0ed19..23763359b 100644 --- a/src/modules/mixer/sys_pulse.c +++ b/src/modules/mixer/sys_pulse.c @@ -18,8 +18,8 @@ static Ecore_Poller *pulse_poller = NULL; static Eina_Hash *queue_states = NULL; static const char *_name = NULL; -static EDBus_Connection *dbus = NULL; -static EDBus_Signal_Handler *dbus_handler = NULL; +static Eldbus_Connection *dbus = NULL; +static Eldbus_Signal_Handler *dbus_handler = NULL; static Ecore_Timer *disc_timer = NULL; static unsigned int disc_count = 0; @@ -38,10 +38,10 @@ _pulse_poller_cb(void *d __UNUSED__) } static void -_dbus_poll(void *data EINA_UNUSED, const EDBus_Message *msg) +_dbus_poll(void *data EINA_UNUSED, const Eldbus_Message *msg) { const char *name, *from, *to; - if (edbus_message_arguments_get(msg, "sss", &name, &from, &to)) + if (eldbus_message_arguments_get(msg, "sss", &name, &from, &to)) { if (!strcmp(name, PULSE_BUS)) e_mixer_pulse_init(); @@ -49,32 +49,32 @@ _dbus_poll(void *data EINA_UNUSED, const EDBus_Message *msg) if (dbus_handler) { - edbus_signal_handler_del(dbus_handler); + eldbus_signal_handler_del(dbus_handler); dbus_handler = NULL; } if (dbus) { - edbus_connection_unref(dbus); + eldbus_connection_unref(dbus); dbus = NULL; - edbus_shutdown(); + eldbus_shutdown(); } } static void -_dbus_test(void *data EINA_UNUSED, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +_dbus_test(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { - if (edbus_message_error_get(msg, NULL, NULL)) + if (eldbus_message_error_get(msg, NULL, NULL)) { if (dbus_handler) { - edbus_signal_handler_del(dbus_handler); + eldbus_signal_handler_del(dbus_handler); dbus_handler = NULL; } if (dbus) { - edbus_connection_unref(dbus); + eldbus_connection_unref(dbus); dbus = NULL; - edbus_shutdown(); + eldbus_shutdown(); } e_mod_mixer_pulse_ready(EINA_FALSE); return; @@ -342,15 +342,15 @@ e_mixer_pulse_init(void) if (dbus) goto error; if ((!conn) || (!pulse_connect(conn))) { - EDBus_Message *msg; + Eldbus_Message *msg; double interval; - edbus_init(); - dbus = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + eldbus_init(); + dbus = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); if (!dbus) { - edbus_shutdown(); + eldbus_shutdown(); return EINA_FALSE; } @@ -362,13 +362,13 @@ e_mixer_pulse_init(void) _pulse_poller_cb, NULL); } if (!dbus_handler) - dbus_handler = edbus_signal_handler_add(dbus, EDBUS_FDO_BUS, - EDBUS_FDO_PATH, - EDBUS_FDO_INTERFACE, + dbus_handler = eldbus_signal_handler_add(dbus, ELDBUS_FDO_BUS, + ELDBUS_FDO_PATH, + ELDBUS_FDO_INTERFACE, "NameOwnerChanged", _dbus_poll, NULL); - msg = edbus_message_method_call_new(PULSE_BUS, PULSE_PATH, PULSE_INTERFACE, "suuuuuup"); - edbus_connection_send(dbus, msg, _dbus_test, NULL, -1); /* test for not running pulse */ + msg = eldbus_message_method_call_new(PULSE_BUS, PULSE_PATH, PULSE_INTERFACE, "suuuuuup"); + eldbus_connection_send(dbus, msg, _dbus_test, NULL, -1); /* test for not running pulse */ pulse_free(conn); conn = NULL; pulse_shutdown(); @@ -414,14 +414,14 @@ e_mixer_pulse_shutdown(void) queue_states = NULL; if (dbus_handler) { - edbus_signal_handler_del(dbus_handler); + eldbus_signal_handler_del(dbus_handler); dbus_handler = NULL; } if (dbus) { - edbus_connection_unref(dbus); + eldbus_connection_unref(dbus); dbus = NULL; - edbus_shutdown(); + eldbus_shutdown(); } pulse_shutdown(); if (_name) eina_stringshare_del(_name); diff --git a/src/modules/msgbus/e_mod_main.c b/src/modules/msgbus/e_mod_main.c index 79ee80035..dd38e726a 100644 --- a/src/modules/msgbus/e_mod_main.c +++ b/src/modules/msgbus/e_mod_main.c @@ -25,11 +25,11 @@ e_modapi_init(E_Module *m) EAPI int e_modapi_shutdown(E_Module *m __UNUSED__) { - EDBus_Service_Interface* iface; + Eldbus_Service_Interface* iface; Eina_Array_Iterator iter; size_t i; EINA_ARRAY_ITER_NEXT(ifaces, i, iface, iter) - edbus_service_interface_unregister(iface); + eldbus_service_interface_unregister(iface); eina_array_free(ifaces); ifaces = NULL; return 1; diff --git a/src/modules/msgbus/msgbus_audit.c b/src/modules/msgbus/msgbus_audit.c index c880cba82..62b421982 100644 --- a/src/modules/msgbus/msgbus_audit.c +++ b/src/modules/msgbus/msgbus_audit.c @@ -10,35 +10,35 @@ static int _log_dom = -1; #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) -static EDBus_Message * -cb_audit_timer_dump(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_audit_timer_dump(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); char *tmp; tmp = ecore_timer_dump(); if (!tmp) - edbus_message_arguments_append(reply, "s", + eldbus_message_arguments_append(reply, "s", "Not enable, recompile Ecore with ecore_timer_dump."); else - edbus_message_arguments_append(reply, "s", tmp); + eldbus_message_arguments_append(reply, "s", tmp); return reply; } -static const EDBus_Method methods[] = { - { "Timers", NULL, EDBUS_ARGS({"s", ""}), cb_audit_timer_dump }, +static const Eldbus_Method methods[] = { + { "Timers", NULL, ELDBUS_ARGS({"s", ""}), cb_audit_timer_dump }, { } }; -static const EDBus_Service_Interface_Desc audit = { +static const Eldbus_Service_Interface_Desc audit = { "org.enlightenment.wm.Audit", methods }; void msgbus_audit_init(Eina_Array *ifaces) { - EDBus_Service_Interface *iface; + Eldbus_Service_Interface *iface; if (_log_dom == -1) { diff --git a/src/modules/msgbus/msgbus_desktop.c b/src/modules/msgbus/msgbus_desktop.c index 2fb41e7cc..34999dac8 100644 --- a/src/modules/msgbus/msgbus_desktop.c +++ b/src/modules/msgbus/msgbus_desktop.c @@ -10,12 +10,12 @@ static int _log_dom = -1; #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) -static EDBus_Message * -cb_virtual_desktops(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_virtual_desktops(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); - edbus_message_arguments_append(reply, "ii", e_config->zone_desks_x_count, + Eldbus_Message *reply = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(reply, "ii", e_config->zone_desks_x_count, e_config->zone_desks_y_count); DBG("GetVirtualCount: %d %d", e_config->zone_desks_x_count, e_config->zone_desks_y_count); @@ -23,15 +23,15 @@ cb_virtual_desktops(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -cb_desktop_show(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_show(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { int x, y; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); E_Zone *zone; - if (!edbus_message_arguments_get(msg, "ii", &x, &y)) + if (!eldbus_message_arguments_get(msg, "ii", &x, &y)) { ERR("could not get Show arguments"); return reply; @@ -44,16 +44,16 @@ cb_desktop_show(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -cb_desktop_show_by_name(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_show_by_name(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); const char *name; E_Zone *zone; unsigned int i, count; - if (!edbus_message_arguments_get(msg, "s", &name)) + if (!eldbus_message_arguments_get(msg, "s", &name)) { ERR("could not get Show arguments"); return reply; @@ -76,35 +76,35 @@ cb_desktop_show_by_name(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -cb_desktop_lock(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_lock(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { DBG("desklock requested"); e_desklock_show(EINA_FALSE); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -cb_desktop_unlock(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_unlock(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { DBG("deskunlock requested"); e_desklock_hide(); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } -static EDBus_Message * -cb_desktop_bgadd(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_bgadd(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { int container, zone, desk_x, desk_y; const char *path; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "iiiis", &container, &zone, &desk_x, + if (!eldbus_message_arguments_get(msg, "iiiis", &container, &zone, &desk_x, &desk_y, &path)) { ERR("could not get Add arguments"); @@ -120,14 +120,14 @@ cb_desktop_bgadd(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -cb_desktop_bgdel(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_bgdel(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { int container, zone, desk_x, desk_y; - EDBus_Message *reply = edbus_message_method_return_new(msg); + Eldbus_Message *reply = eldbus_message_method_return_new(msg); - if (!edbus_message_arguments_get(msg, "iiii", &container, &zone, &desk_x, + if (!eldbus_message_arguments_get(msg, "iiii", &container, &zone, &desk_x, &desk_y)) { ERR("could not get Del arguments"); @@ -143,28 +143,28 @@ cb_desktop_bgdel(const EDBus_Service_Interface *iface __UNUSED__, return reply; } -static EDBus_Message * -cb_desktop_bglist(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_desktop_bglist(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { Eina_List *list; E_Config_Desktop_Background *bg; - EDBus_Message *reply = edbus_message_method_return_new(msg); - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message *reply = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *main_iter, *array; if (!reply) return NULL; - main_iter = edbus_message_iter_get(reply); + main_iter = eldbus_message_iter_get(reply); if (!main_iter) return reply; - if (!edbus_message_iter_arguments_append(main_iter, "a(iiiis)", &array)) + if (!eldbus_message_iter_arguments_append(main_iter, "a(iiiis)", &array)) return reply; EINA_LIST_FOREACH(e_config->desktop_backgrounds, list, bg) { - EDBus_Message_Iter *s; + Eldbus_Message_Iter *s; if (!bg || !bg->file) { @@ -172,50 +172,50 @@ cb_desktop_bglist(const EDBus_Service_Interface *iface __UNUSED__, } DBG("Background container=%d zone=%d pos=%d,%d path=%s", bg->container, bg->zone, bg->desk_x, bg->desk_y, bg->file); - edbus_message_iter_arguments_append(array, "(iiiis)", &s); + eldbus_message_iter_arguments_append(array, "(iiiis)", &s); if (!s) continue; - edbus_message_iter_arguments_append(s, "iiiis", bg->container, bg->zone, + eldbus_message_iter_arguments_append(s, "iiiis", bg->container, bg->zone, bg->desk_x, bg->desk_y, bg->file); - edbus_message_iter_container_close(array, s); + eldbus_message_iter_container_close(array, s); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } -static const EDBus_Method desktop_methods[] = { - { "GetVirtualCount", NULL, EDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}), +static const Eldbus_Method desktop_methods[] = { + { "GetVirtualCount", NULL, ELDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}), cb_virtual_desktops }, - { "Show", EDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}), NULL, + { "Show", ELDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}), NULL, cb_desktop_show }, - { "ShowByName", EDBUS_ARGS({"s", "desk_name"}), NULL, + { "ShowByName", ELDBUS_ARGS({"s", "desk_name"}), NULL, cb_desktop_show_by_name }, { "Lock", NULL, NULL, cb_desktop_lock }, { "Unlock", NULL, NULL, cb_desktop_unlock }, { } }; -static const EDBus_Method background_methods[] = { +static const Eldbus_Method background_methods[] = { { "Add", - EDBUS_ARGS({"i", "container"}, {"i", "zone"}, {"i", "desk_x"}, {"i", "desk_y"}, {"s", "path"}), + ELDBUS_ARGS({"i", "container"}, {"i", "zone"}, {"i", "desk_x"}, {"i", "desk_y"}, {"s", "path"}), NULL, cb_desktop_bgadd }, - { "Del", EDBUS_ARGS({"i", "container"}, {"i", "zone"}, {"i", "desk_x"}, {"i", "desk_y"}), + { "Del", ELDBUS_ARGS({"i", "container"}, {"i", "zone"}, {"i", "desk_x"}, {"i", "desk_y"}), NULL, cb_desktop_bgdel }, - { "List", EDBUS_ARGS({"a(iiiis)", "array_of_bg"}), NULL, cb_desktop_bglist }, + { "List", ELDBUS_ARGS({"a(iiiis)", "array_of_bg"}), NULL, cb_desktop_bglist }, { } }; -static const EDBus_Service_Interface_Desc desktop = { +static const Eldbus_Service_Interface_Desc desktop = { "org.enlightenment.wm.Desktop", desktop_methods }; -static const EDBus_Service_Interface_Desc bg = { +static const Eldbus_Service_Interface_Desc bg = { "org.enlightenment.wm.Desktop.Background", background_methods }; void msgbus_desktop_init(Eina_Array *ifaces) { - EDBus_Service_Interface *iface; + Eldbus_Service_Interface *iface; if (_log_dom == -1) { diff --git a/src/modules/msgbus/msgbus_lang.c b/src/modules/msgbus/msgbus_lang.c index a48fe1586..e603bcadb 100644 --- a/src/modules/msgbus/msgbus_lang.c +++ b/src/modules/msgbus/msgbus_lang.c @@ -10,45 +10,45 @@ static int _log_dom = -1; #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) -static EDBus_Message * -cb_langs(const EDBus_Service_Interface *iface __UNUSED__, - const EDBus_Message *msg) +static Eldbus_Message * +cb_langs(const Eldbus_Service_Interface *iface __UNUSED__, + const Eldbus_Message *msg) { - EDBus_Message *reply = edbus_message_method_return_new(msg); - EDBus_Message_Iter *main_iter, *array; + Eldbus_Message *reply = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *main_iter, *array; const Eina_List *l; const char *str; if (!reply) return NULL; - main_iter = edbus_message_iter_get(reply); - edbus_message_iter_arguments_append(main_iter, "as", &array); + main_iter = eldbus_message_iter_get(reply); + eldbus_message_iter_arguments_append(main_iter, "as", &array); if (!array) return reply; EINA_LIST_FOREACH(e_intl_language_list(), l, str) { DBG("language: %s", str); - edbus_message_iter_basic_append(array, 's', str); + eldbus_message_iter_basic_append(array, 's', str); } - edbus_message_iter_container_close(main_iter, array); + eldbus_message_iter_container_close(main_iter, array); return reply; } -static const EDBus_Method methods[] = { +static const Eldbus_Method methods[] = { { - "List", NULL, EDBUS_ARGS({"as", "langs"}), cb_langs, 0 + "List", NULL, ELDBUS_ARGS({"as", "langs"}), cb_langs, 0 }, { NULL, NULL, NULL, NULL, 0 } }; -static const EDBus_Service_Interface_Desc lang = { +static const Eldbus_Service_Interface_Desc lang = { "org.enlightenment.wm.Language", methods, NULL, NULL, NULL, NULL }; void msgbus_lang_init(Eina_Array *ifaces) { - EDBus_Service_Interface *iface; + Eldbus_Service_Interface *iface; if (_log_dom == -1) { _log_dom = eina_log_domain_register("msgbus_lang", EINA_COLOR_BLUE); diff --git a/src/modules/music-control/e_mod_main.c b/src/modules/music-control/e_mod_main.c index 233c7f2e5..9b11fcec4 100644 --- a/src/modules/music-control/e_mod_main.c +++ b/src/modules/music-control/e_mod_main.c @@ -208,7 +208,7 @@ static const E_Gadcon_Client_Class _gc_class = EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, _e_music_control_Name }; static void -cb_playback_status_get(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, const char *value) +cb_playback_status_get(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, const char *value) { E_Music_Control_Module_Context *ctxt = data; @@ -226,9 +226,9 @@ cb_playback_status_get(void *data, EDBus_Pending *p, const char *propname, EDBus } static void -prop_changed(void *data, EDBus_Proxy *proxy, void *event_info) +prop_changed(void *data, Eldbus_Proxy *proxy, void *event_info) { - EDBus_Proxy_Event_Property_Changed *event = event_info; + Eldbus_Proxy_Event_Property_Changed *event = event_info; E_Music_Control_Module_Context *ctxt = data; if (!strcmp(event->name, "PlaybackStatus")) @@ -248,14 +248,14 @@ prop_changed(void *data, EDBus_Proxy *proxy, void *event_info) Eina_Bool music_control_dbus_init(E_Music_Control_Module_Context *ctxt, const char *bus) { - edbus_init(); - ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + eldbus_init(); + ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); EINA_SAFETY_ON_NULL_RETURN_VAL(ctxt->conn, EINA_FALSE); ctxt->mrpis2 = mpris_media_player2_proxy_get(ctxt->conn, bus, NULL); ctxt->mpris2_player = media_player2_player_proxy_get(ctxt->conn, bus, NULL); media_player2_player_playback_status_propget(ctxt->mpris2_player, cb_playback_status_get, ctxt); - edbus_proxy_event_callback_add(ctxt->mpris2_player, EDBUS_PROXY_EVENT_PROPERTY_CHANGED, + eldbus_proxy_event_callback_add(ctxt->mpris2_player, ELDBUS_PROXY_EVENT_PROPERTY_CHANGED, prop_changed, ctxt); return EINA_TRUE; } @@ -310,8 +310,8 @@ e_modapi_shutdown(E_Module *m) media_player2_player_proxy_unref(ctxt->mpris2_player); mpris_media_player2_proxy_unref(ctxt->mrpis2); - edbus_connection_unref(ctxt->conn); - edbus_shutdown(); + eldbus_connection_unref(ctxt->conn); + eldbus_shutdown(); e_gadcon_provider_unregister(&_gc_class); diff --git a/src/modules/music-control/gen/edbus_media_player2_player.c b/src/modules/music-control/gen/edbus_media_player2_player.c deleted file mode 100644 index 1e472fe00..000000000 --- a/src/modules/music-control/gen/edbus_media_player2_player.c +++ /dev/null @@ -1,923 +0,0 @@ -#include "edbus_media_player2_player.h" - -static int _log_main = -1; -#undef ERR -#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__); -int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT; - -void -media_player2_player_next_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Next"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_open_uri_call(EDBus_Proxy *proxy, const char *arg0) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "OpenUri"); - if (!edbus_message_arguments_append(msg, "s", arg0)) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_pause_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Pause"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_play_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Play"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_play_pause_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "PlayPause"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_previous_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Previous"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_seek_call(EDBus_Proxy *proxy, int64_t arg0) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Seek"); - if (!edbus_message_arguments_append(msg, "x", arg0)) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_set_position_call(EDBus_Proxy *proxy, const char *arg0, int64_t arg1) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "SetPosition"); - if (!edbus_message_arguments_append(msg, "ox", arg0, arg1)) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -media_player2_player_stop_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Stop"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -static void -media_player2_player_seeked_data_free(void *user_data, void *func_data) -{ - Media_Player2_Player_Seeked_Data *s_data = user_data; - free(s_data); -} - -static void -on_media_player2_player_seeked(void *data, const EDBus_Message *msg) -{ - EDBus_Proxy *proxy = data; - Media_Player2_Player_Seeked_Data *s_data = calloc(1, sizeof(Media_Player2_Player_Seeked_Data)); - s_data->proxy = proxy; - if (!edbus_message_arguments_get(msg, "x", &s_data->arg0)) - { - ERR("Error: Getting arguments from message."); - return; - } - ecore_event_add(MEDIA_PLAYER2_PLAYER_SEEKED_EVENT, s_data, media_player2_player_seeked_data_free, NULL); -} - -static void -cb_media_player2_player_can_control(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanControl", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanControl", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanControl", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanControl", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_control_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanControl", cb_media_player2_player_can_control, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_can_go_next(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanGoNext", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_go_next_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanGoNext", cb_media_player2_player_can_go_next, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_can_go_previous(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanGoPrevious", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_go_previous_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanGoPrevious", cb_media_player2_player_can_go_previous, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_can_pause(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanPause", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanPause", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanPause", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanPause", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_pause_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanPause", cb_media_player2_player_can_pause, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_can_play(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanPlay", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanPlay", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanPlay", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanPlay", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_play_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanPlay", cb_media_player2_player_can_play, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_can_seek(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanSeek", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanSeek", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanSeek", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanSeek", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_can_seek_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanSeek", cb_media_player2_player_can_seek, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_loop_status(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_String_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - const char *v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); - return; - } - if (!edbus_message_iter_arguments_get(variant, "s", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); - return; - } - cb(user_data, pending, "LoopStatus", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_loop_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "LoopStatus", cb_media_player2_player_loop_status, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_loop_status_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - const char *error, *error_msg; - void *user_data = edbus_pending_data_del(pending, "__user_data"); - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Codegen_Property_Set_Cb cb = data; - if (edbus_message_error_get(msg, &error, &error_msg)) { - EDBus_Error_Info error_info = {error, error_msg}; - - cb(user_data, "LoopStatus", proxy, pending, &error_info); - return; - } - cb(user_data, "LoopStatus", proxy, pending, NULL); -} - -EDBus_Pending * -media_player2_player_loop_status_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); - p = edbus_proxy_property_set(proxy, "LoopStatus", "s", value, cb_media_player2_player_loop_status_set, data); - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_maximum_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Double_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - double v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "d", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "MaximumRate", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_maximum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "MaximumRate", cb_media_player2_player_maximum_rate, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_metadata(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Complex_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Value *v, stack_value; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Metadata", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Metadata", proxy, &error_info, NULL); - return; - } - v = edbus_message_iter_struct_like_to_eina_value(variant); - eina_value_struct_value_get(v, "arg0", &stack_value); - cb(user_data, pending, "Metadata", proxy, NULL, &stack_value); - eina_value_flush(&stack_value); - eina_value_free(v); -} - -EDBus_Pending * -media_player2_player_metadata_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Metadata", cb_media_player2_player_metadata, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_minimum_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Double_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - double v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "d", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "MinimumRate", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_minimum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "MinimumRate", cb_media_player2_player_minimum_rate, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_playback_status(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_String_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - const char *v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); - return; - } - if (!edbus_message_iter_arguments_get(variant, "s", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); - return; - } - cb(user_data, pending, "PlaybackStatus", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_playback_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "PlaybackStatus", cb_media_player2_player_playback_status, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_position(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Int64_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - int64_t v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Position", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Position", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "x", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Position", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "Position", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_position_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Int64_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Position", cb_media_player2_player_position, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Double_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - double v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Rate", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Rate", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "d", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Rate", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "Rate", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Rate", cb_media_player2_player_rate, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_rate_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - const char *error, *error_msg; - void *user_data = edbus_pending_data_del(pending, "__user_data"); - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Codegen_Property_Set_Cb cb = data; - if (edbus_message_error_get(msg, &error, &error_msg)) { - EDBus_Error_Info error_info = {error, error_msg}; - - cb(user_data, "Rate", proxy, pending, &error_info); - return; - } - cb(user_data, "Rate", proxy, pending, NULL); -} - -EDBus_Pending * -media_player2_player_rate_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); - p = edbus_proxy_property_set(proxy, "Rate", "d", value, cb_media_player2_player_rate_set, data); - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_shuffle(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Shuffle", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Shuffle", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Shuffle", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "Shuffle", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_shuffle_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Shuffle", cb_media_player2_player_shuffle, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_shuffle_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - const char *error, *error_msg; - void *user_data = edbus_pending_data_del(pending, "__user_data"); - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Codegen_Property_Set_Cb cb = data; - if (edbus_message_error_get(msg, &error, &error_msg)) { - EDBus_Error_Info error_info = {error, error_msg}; - - cb(user_data, "Shuffle", proxy, pending, &error_info); - return; - } - cb(user_data, "Shuffle", proxy, pending, NULL); -} - -EDBus_Pending * -media_player2_player_shuffle_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); - p = edbus_proxy_property_set(proxy, "Shuffle", "b", value, cb_media_player2_player_shuffle_set, data); - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_volume(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Double_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - double v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Volume", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Volume", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "d", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Volume", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "Volume", proxy, NULL, v); -} - -EDBus_Pending * -media_player2_player_volume_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Volume", cb_media_player2_player_volume, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_media_player2_player_volume_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - const char *error, *error_msg; - void *user_data = edbus_pending_data_del(pending, "__user_data"); - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Codegen_Property_Set_Cb cb = data; - if (edbus_message_error_get(msg, &error, &error_msg)) { - EDBus_Error_Info error_info = {error, error_msg}; - - cb(user_data, "Volume", proxy, pending, &error_info); - return; - } - cb(user_data, "Volume", proxy, pending, NULL); -} - -EDBus_Pending * -media_player2_player_volume_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); - p = edbus_proxy_property_set(proxy, "Volume", "d", value, cb_media_player2_player_volume_set, data); - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -void -media_player2_player_log_domain_set(int id) -{ - _log_main = id; -} - -void -media_player2_player_proxy_unref(EDBus_Proxy *proxy) -{ - EDBus_Object *obj = edbus_proxy_object_get(proxy); - edbus_proxy_unref(proxy); - edbus_object_unref(obj); -} - -EDBus_Proxy * -media_player2_player_proxy_get(EDBus_Connection *conn, const char *bus, const char *path) -{ - EDBus_Object *obj; - EDBus_Proxy *proxy; - EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); - if (!path) path = "/org/mpris/MediaPlayer2"; - obj = edbus_object_get(conn, bus, path); - proxy = edbus_proxy_get(obj, "org.mpris.MediaPlayer2.Player"); - edbus_proxy_signal_handler_add(proxy, "Seeked", on_media_player2_player_seeked, proxy); - if (!MEDIA_PLAYER2_PLAYER_SEEKED_EVENT) - MEDIA_PLAYER2_PLAYER_SEEKED_EVENT = ecore_event_type_new(); - return proxy; -} diff --git a/src/modules/music-control/gen/edbus_media_player2_player.h b/src/modules/music-control/gen/edbus_media_player2_player.h deleted file mode 100644 index 5f824b7e4..000000000 --- a/src/modules/music-control/gen/edbus_media_player2_player.h +++ /dev/null @@ -1,47 +0,0 @@ -#ifndef EDBUS_MEDIA_PLAYER2_PLAYER_H -#define EDBUS_MEDIA_PLAYER2_PLAYER_H - -#include -#include -#include -#include "edbus_utils.h" - -EDBus_Proxy *media_player2_player_proxy_get(EDBus_Connection *conn, const char *bus, const char *path); -void media_player2_player_proxy_unref(EDBus_Proxy *proxy); -void media_player2_player_log_domain_set(int id); -void media_player2_player_next_call(EDBus_Proxy *proxy); -void media_player2_player_open_uri_call(EDBus_Proxy *proxy, const char *arg0); -void media_player2_player_pause_call(EDBus_Proxy *proxy); -void media_player2_player_play_call(EDBus_Proxy *proxy); -void media_player2_player_play_pause_call(EDBus_Proxy *proxy); -void media_player2_player_previous_call(EDBus_Proxy *proxy); -void media_player2_player_seek_call(EDBus_Proxy *proxy, int64_t arg0); -void media_player2_player_set_position_call(EDBus_Proxy *proxy, const char *arg0, int64_t arg1); -void media_player2_player_stop_call(EDBus_Proxy *proxy); -extern int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT; -typedef struct _Media_Player2_Player_Seeked_Data -{ - EDBus_Proxy *proxy; - int64_t arg0; -} Media_Player2_Player_Seeked_Data; -EDBus_Pending *media_player2_player_can_control_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_can_go_next_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_can_go_previous_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_can_pause_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_can_play_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_can_seek_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_loop_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_loop_status_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value); -EDBus_Pending *media_player2_player_maximum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_metadata_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_minimum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_playback_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_position_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Int64_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_rate_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value); -EDBus_Pending *media_player2_player_shuffle_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_shuffle_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value); -EDBus_Pending *media_player2_player_volume_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data); -EDBus_Pending *media_player2_player_volume_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value); - -#endif \ No newline at end of file diff --git a/src/modules/music-control/gen/edbus_mpris_media_player2.c b/src/modules/music-control/gen/edbus_mpris_media_player2.c deleted file mode 100644 index 791252453..000000000 --- a/src/modules/music-control/gen/edbus_mpris_media_player2.c +++ /dev/null @@ -1,350 +0,0 @@ -#include "edbus_mpris_media_player2.h" - -static int _log_main = -1; -#undef ERR -#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__); - -void -mpris_media_player2_quit_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Quit"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -void -mpris_media_player2_raise_call(EDBus_Proxy *proxy) -{ - EDBus_Message *msg; - EINA_SAFETY_ON_NULL_RETURN(proxy); - msg = edbus_proxy_method_call_new(proxy, "Raise"); - if (!edbus_message_arguments_append(msg, "")) - { - ERR("Error: Filling message."); - return; - } - edbus_proxy_send(proxy, msg, NULL, NULL, -1); -} - -static void -cb_mpris_media_player2_can_quit(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanQuit", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanQuit", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanQuit", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanQuit", proxy, NULL, v); -} - -EDBus_Pending * -mpris_media_player2_can_quit_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanQuit", cb_mpris_media_player2_can_quit, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_can_raise(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "CanRaise", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanRaise", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "CanRaise", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "CanRaise", proxy, NULL, v); -} - -EDBus_Pending * -mpris_media_player2_can_raise_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "CanRaise", cb_mpris_media_player2_can_raise, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_desktop_entry(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_String_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - const char *v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); - return; - } - if (!edbus_message_iter_arguments_get(variant, "s", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); - return; - } - cb(user_data, pending, "DesktopEntry", proxy, NULL, v); -} - -EDBus_Pending * -mpris_media_player2_desktop_entry_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "DesktopEntry", cb_mpris_media_player2_desktop_entry, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_has_track_list(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Bool_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Bool v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); - return; - } - if (!edbus_message_iter_arguments_get(variant, "b", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); - return; - } - cb(user_data, pending, "HasTrackList", proxy, NULL, v); -} - -EDBus_Pending * -mpris_media_player2_has_track_list_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "HasTrackList", cb_mpris_media_player2_has_track_list, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_identity(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_String_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - const char *v; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "Identity", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Identity", proxy, &error_info, NULL); - return; - } - if (!edbus_message_iter_arguments_get(variant, "s", &v)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "Identity", proxy, &error_info, NULL); - return; - } - cb(user_data, pending, "Identity", proxy, NULL, v); -} - -EDBus_Pending * -mpris_media_player2_identity_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "Identity", cb_mpris_media_player2_identity, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_supported_mime_types(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Complex_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Value *v, stack_value; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL); - return; - } - v = edbus_message_iter_struct_like_to_eina_value(variant); - eina_value_struct_value_get(v, "arg0", &stack_value); - cb(user_data, pending, "SupportedMimeTypes", proxy, NULL, &stack_value); - eina_value_flush(&stack_value); - eina_value_free(v); -} - -EDBus_Pending * -mpris_media_player2_supported_mime_types_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "SupportedMimeTypes", cb_mpris_media_player2_supported_mime_types, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -static void -cb_mpris_media_player2_supported_uri_schemes(void *data, const EDBus_Message *msg, EDBus_Pending *pending) -{ - void *user_data = edbus_pending_data_del(pending, "__user_data"); - const char *error, *error_msg; - EDBus_Codegen_Property_Complex_Get_Cb cb = data; - EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy"); - EDBus_Message_Iter *variant; - Eina_Value *v, stack_value; - if (edbus_message_error_get(msg, &error, &error_msg)) - { - EDBus_Error_Info error_info = {error, error_msg}; - cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL); - return; - } - if (!edbus_message_arguments_get(msg, "v", &variant)) - { - EDBus_Error_Info error_info = {"", ""}; - cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL); - return; - } - v = edbus_message_iter_struct_like_to_eina_value(variant); - eina_value_struct_value_get(v, "arg0", &stack_value); - cb(user_data, pending, "SupportedUriSchemes", proxy, NULL, &stack_value); - eina_value_flush(&stack_value); - eina_value_free(v); -} - -EDBus_Pending * -mpris_media_player2_supported_uri_schemes_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data) -{ - EDBus_Pending *p; - EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); - p = edbus_proxy_property_get(proxy, "SupportedUriSchemes", cb_mpris_media_player2_supported_uri_schemes, cb); - if (data) - edbus_pending_data_set(p, "__user_data", data); - edbus_pending_data_set(p, "__proxy", proxy); - return p; -} - -void -mpris_media_player2_log_domain_set(int id) -{ - _log_main = id; -} - -void -mpris_media_player2_proxy_unref(EDBus_Proxy *proxy) -{ - EDBus_Object *obj = edbus_proxy_object_get(proxy); - edbus_proxy_unref(proxy); - edbus_object_unref(obj); -} - -EDBus_Proxy * -mpris_media_player2_proxy_get(EDBus_Connection *conn, const char *bus, const char *path) -{ - EDBus_Object *obj; - EDBus_Proxy *proxy; - EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL); - EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); - if (!path) path = "/org/mpris/MediaPlayer2"; - obj = edbus_object_get(conn, bus, path); - proxy = edbus_proxy_get(obj, "org.mpris.MediaPlayer2"); - return proxy; -} diff --git a/src/modules/music-control/gen/edbus_mpris_media_player2.h b/src/modules/music-control/gen/edbus_mpris_media_player2.h deleted file mode 100644 index e953a7dbe..000000000 --- a/src/modules/music-control/gen/edbus_mpris_media_player2.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef EDBUS_MPRIS_MEDIA_PLAYER2_H -#define EDBUS_MPRIS_MEDIA_PLAYER2_H - -#include -#include -#include -#include "edbus_utils.h" - -EDBus_Proxy *mpris_media_player2_proxy_get(EDBus_Connection *conn, const char *bus, const char *path); -void mpris_media_player2_proxy_unref(EDBus_Proxy *proxy); -void mpris_media_player2_log_domain_set(int id); -void mpris_media_player2_quit_call(EDBus_Proxy *proxy); -void mpris_media_player2_raise_call(EDBus_Proxy *proxy); -EDBus_Pending *mpris_media_player2_can_quit_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_can_raise_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_desktop_entry_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_has_track_list_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_identity_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_supported_mime_types_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data); -EDBus_Pending *mpris_media_player2_supported_uri_schemes_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data); - -#endif \ No newline at end of file diff --git a/src/modules/music-control/gen/edbus_utils.h b/src/modules/music-control/gen/edbus_utils.h deleted file mode 100644 index e3df56156..000000000 --- a/src/modules/music-control/gen/edbus_utils.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef EDBUS_UTILS_H -#define EDBUS_UTILS_H 1 - -typedef struct _EDBus_Error_Info -{ - const char *error; - const char *message; -} EDBus_Error_Info; - -typedef void (*EDBus_Codegen_Property_Set_Cb)(void *data, const char *propname, EDBus_Proxy *proxy, EDBus_Pending *p, EDBus_Error_Info *error_info); - -typedef void (*EDBus_Codegen_Property_String_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, const char *value); -typedef void (*EDBus_Codegen_Property_Int32_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, int value); -typedef void (*EDBus_Codegen_Property_Byte_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned char value); -typedef void (*EDBus_Codegen_Property_Bool_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, Eina_Bool value); -typedef void (*EDBus_Codegen_Property_Int16_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, short int value); -typedef void (*EDBus_Codegen_Property_Uint16_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned short int value); -typedef void (*EDBus_Codegen_Property_Uint32_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned int value); -typedef void (*EDBus_Codegen_Property_Double_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, double value); -typedef void (*EDBus_Codegen_Property_Int64_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, int64_t value); -typedef void (*EDBus_Codegen_Property_Uint64_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, uint64_t value); -typedef void (*EDBus_Codegen_Property_Complex_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, Eina_Value *value); - -#endif \ No newline at end of file diff --git a/src/modules/music-control/gen/eldbus_media_player2_player.c b/src/modules/music-control/gen/eldbus_media_player2_player.c new file mode 100644 index 000000000..eac833316 --- /dev/null +++ b/src/modules/music-control/gen/eldbus_media_player2_player.c @@ -0,0 +1,923 @@ +#include "eldbus_media_player2_player.h" + +static int _log_main = -1; +#undef ERR +#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__); +int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT; + +void +media_player2_player_next_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Next"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_open_uri_call(Eldbus_Proxy *proxy, const char *arg0) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "OpenUri"); + if (!eldbus_message_arguments_append(msg, "s", arg0)) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_pause_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Pause"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_play_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Play"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_play_pause_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "PlayPause"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_previous_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Previous"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_seek_call(Eldbus_Proxy *proxy, int64_t arg0) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Seek"); + if (!eldbus_message_arguments_append(msg, "x", arg0)) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_set_position_call(Eldbus_Proxy *proxy, const char *arg0, int64_t arg1) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "SetPosition"); + if (!eldbus_message_arguments_append(msg, "ox", arg0, arg1)) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +media_player2_player_stop_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Stop"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +static void +media_player2_player_seeked_data_free(void *user_data, void *func_data) +{ + Media_Player2_Player_Seeked_Data *s_data = user_data; + free(s_data); +} + +static void +on_media_player2_player_seeked(void *data, const Eldbus_Message *msg) +{ + Eldbus_Proxy *proxy = data; + Media_Player2_Player_Seeked_Data *s_data = calloc(1, sizeof(Media_Player2_Player_Seeked_Data)); + s_data->proxy = proxy; + if (!eldbus_message_arguments_get(msg, "x", &s_data->arg0)) + { + ERR("Error: Getting arguments from message."); + return; + } + ecore_event_add(MEDIA_PLAYER2_PLAYER_SEEKED_EVENT, s_data, media_player2_player_seeked_data_free, NULL); +} + +static void +cb_media_player2_player_can_control(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanControl", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanControl", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanControl", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanControl", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_control_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanControl", cb_media_player2_player_can_control, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_can_go_next(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanGoNext", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanGoNext", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_go_next_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanGoNext", cb_media_player2_player_can_go_next, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_can_go_previous(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanGoPrevious", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_go_previous_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanGoPrevious", cb_media_player2_player_can_go_previous, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_can_pause(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanPause", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanPause", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanPause", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanPause", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_pause_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanPause", cb_media_player2_player_can_pause, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_can_play(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanPlay", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanPlay", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanPlay", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanPlay", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_play_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanPlay", cb_media_player2_player_can_play, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_can_seek(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanSeek", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanSeek", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanSeek", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanSeek", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_can_seek_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanSeek", cb_media_player2_player_can_seek, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_loop_status(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_String_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + const char *v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "s", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL); + return; + } + cb(user_data, pending, "LoopStatus", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_loop_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "LoopStatus", cb_media_player2_player_loop_status, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_loop_status_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + const char *error, *error_msg; + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Codegen_Property_Set_Cb cb = data; + if (eldbus_message_error_get(msg, &error, &error_msg)) { + Eldbus_Error_Info error_info = {error, error_msg}; + + cb(user_data, "LoopStatus", proxy, pending, &error_info); + return; + } + cb(user_data, "LoopStatus", proxy, pending, NULL); +} + +Eldbus_Pending * +media_player2_player_loop_status_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); + p = eldbus_proxy_property_set(proxy, "LoopStatus", "s", value, cb_media_player2_player_loop_status_set, data); + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_maximum_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Double_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + double v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "d", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "MaximumRate", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "MaximumRate", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_maximum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "MaximumRate", cb_media_player2_player_maximum_rate, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_metadata(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Complex_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Value *v, stack_value; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Metadata", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Metadata", proxy, &error_info, NULL); + return; + } + v = eldbus_message_iter_struct_like_to_eina_value(variant); + eina_value_struct_value_get(v, "arg0", &stack_value); + cb(user_data, pending, "Metadata", proxy, NULL, &stack_value); + eina_value_flush(&stack_value); + eina_value_free(v); +} + +Eldbus_Pending * +media_player2_player_metadata_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Metadata", cb_media_player2_player_metadata, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_minimum_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Double_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + double v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "d", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "MinimumRate", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "MinimumRate", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_minimum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "MinimumRate", cb_media_player2_player_minimum_rate, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_playback_status(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_String_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + const char *v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "s", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL); + return; + } + cb(user_data, pending, "PlaybackStatus", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_playback_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "PlaybackStatus", cb_media_player2_player_playback_status, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_position(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Int64_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + int64_t v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Position", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Position", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "x", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Position", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "Position", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_position_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Int64_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Position", cb_media_player2_player_position, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Double_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + double v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Rate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Rate", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "d", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Rate", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "Rate", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Rate", cb_media_player2_player_rate, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_rate_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + const char *error, *error_msg; + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Codegen_Property_Set_Cb cb = data; + if (eldbus_message_error_get(msg, &error, &error_msg)) { + Eldbus_Error_Info error_info = {error, error_msg}; + + cb(user_data, "Rate", proxy, pending, &error_info); + return; + } + cb(user_data, "Rate", proxy, pending, NULL); +} + +Eldbus_Pending * +media_player2_player_rate_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); + p = eldbus_proxy_property_set(proxy, "Rate", "d", value, cb_media_player2_player_rate_set, data); + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_shuffle(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Shuffle", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Shuffle", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Shuffle", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "Shuffle", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_shuffle_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Shuffle", cb_media_player2_player_shuffle, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_shuffle_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + const char *error, *error_msg; + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Codegen_Property_Set_Cb cb = data; + if (eldbus_message_error_get(msg, &error, &error_msg)) { + Eldbus_Error_Info error_info = {error, error_msg}; + + cb(user_data, "Shuffle", proxy, pending, &error_info); + return; + } + cb(user_data, "Shuffle", proxy, pending, NULL); +} + +Eldbus_Pending * +media_player2_player_shuffle_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); + p = eldbus_proxy_property_set(proxy, "Shuffle", "b", value, cb_media_player2_player_shuffle_set, data); + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_volume(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Double_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + double v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Volume", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Volume", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "d", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Volume", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "Volume", proxy, NULL, v); +} + +Eldbus_Pending * +media_player2_player_volume_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Volume", cb_media_player2_player_volume, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_media_player2_player_volume_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + const char *error, *error_msg; + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Codegen_Property_Set_Cb cb = data; + if (eldbus_message_error_get(msg, &error, &error_msg)) { + Eldbus_Error_Info error_info = {error, error_msg}; + + cb(user_data, "Volume", proxy, pending, &error_info); + return; + } + cb(user_data, "Volume", proxy, pending, NULL); +} + +Eldbus_Pending * +media_player2_player_volume_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); + p = eldbus_proxy_property_set(proxy, "Volume", "d", value, cb_media_player2_player_volume_set, data); + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +void +media_player2_player_log_domain_set(int id) +{ + _log_main = id; +} + +void +media_player2_player_proxy_unref(Eldbus_Proxy *proxy) +{ + Eldbus_Object *obj = eldbus_proxy_object_get(proxy); + eldbus_proxy_unref(proxy); + eldbus_object_unref(obj); +} + +Eldbus_Proxy * +media_player2_player_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path) +{ + Eldbus_Object *obj; + Eldbus_Proxy *proxy; + EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); + if (!path) path = "/org/mpris/MediaPlayer2"; + obj = eldbus_object_get(conn, bus, path); + proxy = eldbus_proxy_get(obj, "org.mpris.MediaPlayer2.Player"); + eldbus_proxy_signal_handler_add(proxy, "Seeked", on_media_player2_player_seeked, proxy); + if (!MEDIA_PLAYER2_PLAYER_SEEKED_EVENT) + MEDIA_PLAYER2_PLAYER_SEEKED_EVENT = ecore_event_type_new(); + return proxy; +} diff --git a/src/modules/music-control/gen/eldbus_media_player2_player.h b/src/modules/music-control/gen/eldbus_media_player2_player.h new file mode 100644 index 000000000..e48a62f77 --- /dev/null +++ b/src/modules/music-control/gen/eldbus_media_player2_player.h @@ -0,0 +1,47 @@ +#ifndef ELDBUS_MEDIA_PLAYER2_PLAYER_H +#define ELDBUS_MEDIA_PLAYER2_PLAYER_H + +#include +#include +#include +#include "eldbus_utils.h" + +Eldbus_Proxy *media_player2_player_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path); +void media_player2_player_proxy_unref(Eldbus_Proxy *proxy); +void media_player2_player_log_domain_set(int id); +void media_player2_player_next_call(Eldbus_Proxy *proxy); +void media_player2_player_open_uri_call(Eldbus_Proxy *proxy, const char *arg0); +void media_player2_player_pause_call(Eldbus_Proxy *proxy); +void media_player2_player_play_call(Eldbus_Proxy *proxy); +void media_player2_player_play_pause_call(Eldbus_Proxy *proxy); +void media_player2_player_previous_call(Eldbus_Proxy *proxy); +void media_player2_player_seek_call(Eldbus_Proxy *proxy, int64_t arg0); +void media_player2_player_set_position_call(Eldbus_Proxy *proxy, const char *arg0, int64_t arg1); +void media_player2_player_stop_call(Eldbus_Proxy *proxy); +extern int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT; +typedef struct _Media_Player2_Player_Seeked_Data +{ + Eldbus_Proxy *proxy; + int64_t arg0; +} Media_Player2_Player_Seeked_Data; +Eldbus_Pending *media_player2_player_can_control_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_can_go_next_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_can_go_previous_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_can_pause_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_can_play_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_can_seek_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_loop_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_loop_status_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value); +Eldbus_Pending *media_player2_player_maximum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_metadata_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_minimum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_playback_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_position_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Int64_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_rate_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value); +Eldbus_Pending *media_player2_player_shuffle_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_shuffle_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value); +Eldbus_Pending *media_player2_player_volume_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data); +Eldbus_Pending *media_player2_player_volume_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value); + +#endif \ No newline at end of file diff --git a/src/modules/music-control/gen/eldbus_mpris_media_player2.c b/src/modules/music-control/gen/eldbus_mpris_media_player2.c new file mode 100644 index 000000000..fa7c7c029 --- /dev/null +++ b/src/modules/music-control/gen/eldbus_mpris_media_player2.c @@ -0,0 +1,350 @@ +#include "eldbus_mpris_media_player2.h" + +static int _log_main = -1; +#undef ERR +#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__); + +void +mpris_media_player2_quit_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Quit"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +void +mpris_media_player2_raise_call(Eldbus_Proxy *proxy) +{ + Eldbus_Message *msg; + EINA_SAFETY_ON_NULL_RETURN(proxy); + msg = eldbus_proxy_method_call_new(proxy, "Raise"); + if (!eldbus_message_arguments_append(msg, "")) + { + ERR("Error: Filling message."); + return; + } + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); +} + +static void +cb_mpris_media_player2_can_quit(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanQuit", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanQuit", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanQuit", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanQuit", proxy, NULL, v); +} + +Eldbus_Pending * +mpris_media_player2_can_quit_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanQuit", cb_mpris_media_player2_can_quit, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_can_raise(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "CanRaise", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanRaise", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "CanRaise", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "CanRaise", proxy, NULL, v); +} + +Eldbus_Pending * +mpris_media_player2_can_raise_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "CanRaise", cb_mpris_media_player2_can_raise, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_desktop_entry(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_String_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + const char *v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "s", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL); + return; + } + cb(user_data, pending, "DesktopEntry", proxy, NULL, v); +} + +Eldbus_Pending * +mpris_media_player2_desktop_entry_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "DesktopEntry", cb_mpris_media_player2_desktop_entry, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_has_track_list(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Bool_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Bool v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "b", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "HasTrackList", proxy, &error_info, 0); + return; + } + cb(user_data, pending, "HasTrackList", proxy, NULL, v); +} + +Eldbus_Pending * +mpris_media_player2_has_track_list_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "HasTrackList", cb_mpris_media_player2_has_track_list, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_identity(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_String_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + const char *v; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "Identity", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Identity", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_iter_arguments_get(variant, "s", &v)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "Identity", proxy, &error_info, NULL); + return; + } + cb(user_data, pending, "Identity", proxy, NULL, v); +} + +Eldbus_Pending * +mpris_media_player2_identity_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "Identity", cb_mpris_media_player2_identity, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_supported_mime_types(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Complex_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Value *v, stack_value; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL); + return; + } + v = eldbus_message_iter_struct_like_to_eina_value(variant); + eina_value_struct_value_get(v, "arg0", &stack_value); + cb(user_data, pending, "SupportedMimeTypes", proxy, NULL, &stack_value); + eina_value_flush(&stack_value); + eina_value_free(v); +} + +Eldbus_Pending * +mpris_media_player2_supported_mime_types_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "SupportedMimeTypes", cb_mpris_media_player2_supported_mime_types, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +static void +cb_mpris_media_player2_supported_uri_schemes(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) +{ + void *user_data = eldbus_pending_data_del(pending, "__user_data"); + const char *error, *error_msg; + Eldbus_Codegen_Property_Complex_Get_Cb cb = data; + Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy"); + Eldbus_Message_Iter *variant; + Eina_Value *v, stack_value; + if (eldbus_message_error_get(msg, &error, &error_msg)) + { + Eldbus_Error_Info error_info = {error, error_msg}; + cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL); + return; + } + if (!eldbus_message_arguments_get(msg, "v", &variant)) + { + Eldbus_Error_Info error_info = {"", ""}; + cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL); + return; + } + v = eldbus_message_iter_struct_like_to_eina_value(variant); + eina_value_struct_value_get(v, "arg0", &stack_value); + cb(user_data, pending, "SupportedUriSchemes", proxy, NULL, &stack_value); + eina_value_flush(&stack_value); + eina_value_free(v); +} + +Eldbus_Pending * +mpris_media_player2_supported_uri_schemes_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data) +{ + Eldbus_Pending *p; + EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL); + p = eldbus_proxy_property_get(proxy, "SupportedUriSchemes", cb_mpris_media_player2_supported_uri_schemes, cb); + if (data) + eldbus_pending_data_set(p, "__user_data", data); + eldbus_pending_data_set(p, "__proxy", proxy); + return p; +} + +void +mpris_media_player2_log_domain_set(int id) +{ + _log_main = id; +} + +void +mpris_media_player2_proxy_unref(Eldbus_Proxy *proxy) +{ + Eldbus_Object *obj = eldbus_proxy_object_get(proxy); + eldbus_proxy_unref(proxy); + eldbus_object_unref(obj); +} + +Eldbus_Proxy * +mpris_media_player2_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path) +{ + Eldbus_Object *obj; + Eldbus_Proxy *proxy; + EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); + if (!path) path = "/org/mpris/MediaPlayer2"; + obj = eldbus_object_get(conn, bus, path); + proxy = eldbus_proxy_get(obj, "org.mpris.MediaPlayer2"); + return proxy; +} diff --git a/src/modules/music-control/gen/eldbus_mpris_media_player2.h b/src/modules/music-control/gen/eldbus_mpris_media_player2.h new file mode 100644 index 000000000..415cec168 --- /dev/null +++ b/src/modules/music-control/gen/eldbus_mpris_media_player2.h @@ -0,0 +1,22 @@ +#ifndef ELDBUS_MPRIS_MEDIA_PLAYER2_H +#define ELDBUS_MPRIS_MEDIA_PLAYER2_H + +#include +#include +#include +#include "eldbus_utils.h" + +Eldbus_Proxy *mpris_media_player2_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path); +void mpris_media_player2_proxy_unref(Eldbus_Proxy *proxy); +void mpris_media_player2_log_domain_set(int id); +void mpris_media_player2_quit_call(Eldbus_Proxy *proxy); +void mpris_media_player2_raise_call(Eldbus_Proxy *proxy); +Eldbus_Pending *mpris_media_player2_can_quit_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_can_raise_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_desktop_entry_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_has_track_list_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_identity_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_supported_mime_types_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data); +Eldbus_Pending *mpris_media_player2_supported_uri_schemes_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data); + +#endif \ No newline at end of file diff --git a/src/modules/music-control/gen/eldbus_utils.h b/src/modules/music-control/gen/eldbus_utils.h new file mode 100644 index 000000000..db4f9ae39 --- /dev/null +++ b/src/modules/music-control/gen/eldbus_utils.h @@ -0,0 +1,24 @@ +#ifndef ELDBUS_UTILS_H +#define ELDBUS_UTILS_H 1 + +typedef struct _Eldbus_Error_Info +{ + const char *error; + const char *message; +} Eldbus_Error_Info; + +typedef void (*Eldbus_Codegen_Property_Set_Cb)(void *data, const char *propname, Eldbus_Proxy *proxy, Eldbus_Pending *p, Eldbus_Error_Info *error_info); + +typedef void (*Eldbus_Codegen_Property_String_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, const char *value); +typedef void (*Eldbus_Codegen_Property_Int32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int value); +typedef void (*Eldbus_Codegen_Property_Byte_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned char value); +typedef void (*Eldbus_Codegen_Property_Bool_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Bool value); +typedef void (*Eldbus_Codegen_Property_Int16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, short int value); +typedef void (*Eldbus_Codegen_Property_Uint16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned short int value); +typedef void (*Eldbus_Codegen_Property_Uint32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned int value); +typedef void (*Eldbus_Codegen_Property_Double_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, double value); +typedef void (*Eldbus_Codegen_Property_Int64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int64_t value); +typedef void (*Eldbus_Codegen_Property_Uint64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, uint64_t value); +typedef void (*Eldbus_Codegen_Property_Complex_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Value *value); + +#endif \ No newline at end of file diff --git a/src/modules/music-control/private.h b/src/modules/music-control/private.h index de78980c9..efae6c07c 100644 --- a/src/modules/music-control/private.h +++ b/src/modules/music-control/private.h @@ -2,8 +2,8 @@ #define MUSIC_CONTROL_PRIVATE_H #include "e_mod_main.h" -#include "gen/edbus_media_player2_player.h" -#include "gen/edbus_mpris_media_player2.h" +#include "gen/eldbus_media_player2_player.h" +#include "gen/eldbus_mpris_media_player2.h" static Ecore_Event_Handler *desklock_handler = NULL; @@ -16,10 +16,10 @@ typedef struct _Music_Control_Config typedef struct _E_Music_Control_Module_Context { Eina_List *instances; - EDBus_Connection *conn; + Eldbus_Connection *conn; Eina_Bool playing:1; - EDBus_Proxy *mrpis2; - EDBus_Proxy *mpris2_player; + Eldbus_Proxy *mrpis2; + Eldbus_Proxy *mpris2_player; E_Config_DD *conf_edd; Music_Control_Config *config; Eina_Bool actions_set:1; diff --git a/src/modules/systray/e_mod_notifier_host.c b/src/modules/systray/e_mod_notifier_host.c index eec4aa24d..5331b1985 100644 --- a/src/modules/systray/e_mod_notifier_host.c +++ b/src/modules/systray/e_mod_notifier_host.c @@ -20,8 +20,8 @@ static Context_Notifier_Host *ctx = NULL; void systray_notifier_item_free(Notifier_Item *item) { - EDBus_Object *obj; - EDBus_Signal_Handler *sig; + Eldbus_Object *obj; + Eldbus_Signal_Handler *sig; Instance_Notifier_Host *host_inst; EINA_INLIST_FOREACH(ctx->instances, host_inst) { @@ -56,10 +56,10 @@ systray_notifier_item_free(Notifier_Item *item) if (item->title) eina_stringshare_del(item->title); EINA_LIST_FREE(item->signals, sig) - edbus_signal_handler_del(sig); - obj = edbus_proxy_object_get(item->proxy); - edbus_proxy_unref(item->proxy); - edbus_object_unref(obj); + eldbus_signal_handler_del(sig); + obj = eldbus_proxy_object_get(item->proxy); + eldbus_proxy_unref(item->proxy); + eldbus_object_unref(obj); ctx->item_list = eina_inlist_remove(ctx->item_list, EINA_INLIST_GET(item)); free(item); } @@ -334,9 +334,9 @@ systray_notifier_host_init(void) void systray_notifier_host_shutdown(void) { - EDBus_Pending *p; + Eldbus_Pending *p; - EINA_LIST_FREE(ctx->pending, p) edbus_pending_cancel(p); + EINA_LIST_FREE(ctx->pending, p) eldbus_pending_cancel(p); systray_notifier_dbus_shutdown(ctx); free(ctx); ctx = NULL; diff --git a/src/modules/systray/e_mod_notifier_host_dbus.c b/src/modules/systray/e_mod_notifier_host_dbus.c index 10048d786..c0a37c0ee 100644 --- a/src/modules/systray/e_mod_notifier_host_dbus.c +++ b/src/modules/systray/e_mod_notifier_host_dbus.c @@ -57,78 +57,78 @@ id_find(const char *s, const char *names[]) } static void -item_prop_get(void *data, const void *key, EDBus_Message_Iter *var) +item_prop_get(void *data, const void *key, Eldbus_Message_Iter *var) { Notifier_Item *item = data; if (!strcmp(key, "Category")) { const char *category; - edbus_message_iter_arguments_get(var, "s", &category); + eldbus_message_iter_arguments_get(var, "s", &category); item->category = id_find(category, Category_Names); } else if (!strcmp(key, "IconName")) { const char *name; - edbus_message_iter_arguments_get(var, "s", &name); + eldbus_message_iter_arguments_get(var, "s", &name); eina_stringshare_replace(&item->icon_name, name); } else if (!strcmp(key, "AttentionIconName")) { const char *name; - edbus_message_iter_arguments_get(var, "s", &name); + eldbus_message_iter_arguments_get(var, "s", &name); eina_stringshare_replace(&item->attention_icon_name, name); } else if (!strcmp(key, "IconThemePath")) { const char *path; - edbus_message_iter_arguments_get(var, "s", &path); + eldbus_message_iter_arguments_get(var, "s", &path); eina_stringshare_replace(&item->icon_path, path); } else if (!strcmp(key, "Menu")) { const char *path; - edbus_message_iter_arguments_get(var, "o", &path); + eldbus_message_iter_arguments_get(var, "o", &path); eina_stringshare_replace(&item->menu_path, path); } else if (!strcmp(key, "Status")) { const char *status; - edbus_message_iter_arguments_get(var, "s", &status); + eldbus_message_iter_arguments_get(var, "s", &status); item->status = id_find(status, Status_Names); } else if (!strcmp(key, "Id")) { const char *id; - edbus_message_iter_arguments_get(var, "s", &id); + eldbus_message_iter_arguments_get(var, "s", &id); eina_stringshare_replace(&item->id, id); } else if (!strcmp(key, "Title")) { const char *title; - edbus_message_iter_arguments_get(var, "s", &title); + eldbus_message_iter_arguments_get(var, "s", &title); eina_stringshare_replace(&item->title, title); } } static void -props_changed(void *data, const EDBus_Message *msg) +props_changed(void *data, const Eldbus_Message *msg) { Notifier_Item *item = data; const char *interface, *menu = item->menu_path; - EDBus_Message_Iter *changed, *invalidate; + Eldbus_Message_Iter *changed, *invalidate; - if (!edbus_message_arguments_get(msg, "sa{sv}as", &interface, &changed, &invalidate)) + if (!eldbus_message_arguments_get(msg, "sa{sv}as", &interface, &changed, &invalidate)) { ERR("Error reading message"); return; } - edbus_message_iter_dict_iterate(changed, "sv", item_prop_get, item); + eldbus_message_iter_dict_iterate(changed, "sv", item_prop_get, item); if (menu != item->menu_path) { - EDBus_Connection *conn = edbus_object_connection_get(edbus_proxy_object_get(item->proxy)); + Eldbus_Connection *conn = eldbus_object_connection_get(eldbus_proxy_object_get(item->proxy)); item->dbus_item = NULL; e_dbusmenu_unload(item->menu_data); item->menu_data = e_dbusmenu_load(conn, item->bus_id, item->menu_path, @@ -138,31 +138,31 @@ props_changed(void *data, const EDBus_Message *msg) } static void -props_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +props_get_all_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { const char *error, *error_name; - EDBus_Message_Iter *dict; + Eldbus_Message_Iter *dict; Notifier_Item *item = data; - EDBus_Connection *conn; + Eldbus_Connection *conn; - if (edbus_message_error_get(msg, &error, &error_name)) + if (eldbus_message_error_get(msg, &error, &error_name)) { ERR("%s %s", error, error_name); return; } - if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) + if (!eldbus_message_arguments_get(msg, "a{sv}", &dict)) { ERR("Error getting arguments."); return; } - edbus_message_iter_dict_iterate(dict, "sv", item_prop_get, item); + eldbus_message_iter_dict_iterate(dict, "sv", item_prop_get, item); if (!item->menu_path) ERR("Notifier item %s dont have menu path.", item->menu_path); - conn = edbus_object_connection_get(edbus_proxy_object_get(item->proxy)); + conn = eldbus_object_connection_get(eldbus_proxy_object_get(item->proxy)); item->menu_data = e_dbusmenu_load(conn, item->bus_id, item->menu_path, item); e_dbusmenu_update_cb_set(item->menu_data, systray_notifier_update_menu); @@ -170,18 +170,18 @@ props_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EI } static Eina_Bool -basic_prop_get(const char *propname, void *data, const EDBus_Message *msg) +basic_prop_get(const char *propname, void *data, const Eldbus_Message *msg) { - EDBus_Message_Iter *var; + Eldbus_Message_Iter *var; const char *error, *error_msg; - if (edbus_message_error_get(msg, &error, &error_msg)) + if (eldbus_message_error_get(msg, &error, &error_msg)) { ERR("%s %s", error, error_msg); return EINA_FALSE; } - if (!edbus_message_arguments_get(msg, "v", &var)) + if (!eldbus_message_arguments_get(msg, "v", &var)) { ERR("Error reading message."); return EINA_FALSE; @@ -191,7 +191,7 @@ basic_prop_get(const char *propname, void *data, const EDBus_Message *msg) } static void -attention_icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +attention_icon_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { Notifier_Item *item = data; const char *propname = "AttentionIconName"; @@ -200,14 +200,14 @@ attention_icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pendi } static void -new_attention_icon_cb(void *data, const EDBus_Message *msg EINA_UNUSED) +new_attention_icon_cb(void *data, const Eldbus_Message *msg EINA_UNUSED) { Notifier_Item *item = data; - edbus_proxy_property_get(item->proxy, "AttentionIconName", attention_icon_get_cb, item); + eldbus_proxy_property_get(item->proxy, "AttentionIconName", attention_icon_get_cb, item); } static void -icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +icon_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { Notifier_Item *item = data; const char *propname = "IconName"; @@ -216,14 +216,14 @@ icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UN } static void -new_icon_cb(void *data, const EDBus_Message *msg EINA_UNUSED) +new_icon_cb(void *data, const Eldbus_Message *msg EINA_UNUSED) { Notifier_Item *item = data; - edbus_proxy_property_get(item->proxy, "IconName", icon_get_cb, item); + eldbus_proxy_property_get(item->proxy, "IconName", icon_get_cb, item); } static void -title_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +title_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { Notifier_Item *item = data; const char *propname = "Title"; @@ -232,18 +232,18 @@ title_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_U } static void -new_title_cb(void *data, const EDBus_Message *msg EINA_UNUSED) +new_title_cb(void *data, const Eldbus_Message *msg EINA_UNUSED) { Notifier_Item *item = data; - edbus_proxy_property_get(item->proxy, "Title", title_get_cb, item); + eldbus_proxy_property_get(item->proxy, "Title", title_get_cb, item); } static void -new_icon_theme_path_cb(void *data, const EDBus_Message *msg) +new_icon_theme_path_cb(void *data, const Eldbus_Message *msg) { Notifier_Item *item = data; const char *path; - if (!edbus_message_arguments_get(msg, "s", &path)) + if (!eldbus_message_arguments_get(msg, "s", &path)) { ERR("Error reading message."); return; @@ -253,11 +253,11 @@ new_icon_theme_path_cb(void *data, const EDBus_Message *msg) } static void -new_status_cb(void *data, const EDBus_Message *msg) +new_status_cb(void *data, const Eldbus_Message *msg) { Notifier_Item *item = data; const char *status; - if (!edbus_message_arguments_get(msg, "s", &status)) + if (!eldbus_message_arguments_get(msg, "s", &status)) { ERR("Error reading message."); return; @@ -269,9 +269,9 @@ new_status_cb(void *data, const EDBus_Message *msg) static void notifier_item_add(const char *path, const char *bus_id, Context_Notifier_Host *ctx) { - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; Notifier_Item *item = calloc(1, sizeof(Notifier_Item)); - EDBus_Signal_Handler *s; + Eldbus_Signal_Handler *s; EINA_SAFETY_ON_NULL_RETURN(item); item->path = path; @@ -279,34 +279,34 @@ notifier_item_add(const char *path, const char *bus_id, Context_Notifier_Host *c ctx->item_list = eina_inlist_append(ctx->item_list, EINA_INLIST_GET(item)); - proxy = edbus_proxy_get(edbus_object_get(ctx->conn, bus_id, path), + proxy = eldbus_proxy_get(eldbus_object_get(ctx->conn, bus_id, path), ITEM_IFACE); item->proxy = proxy; - edbus_proxy_property_get_all(proxy, props_get_all_cb, item); - s = edbus_proxy_properties_changed_callback_add(proxy, props_changed, item); + eldbus_proxy_property_get_all(proxy, props_get_all_cb, item); + s = eldbus_proxy_properties_changed_callback_add(proxy, props_changed, item); item->signals = eina_list_append(item->signals, s); - s = edbus_proxy_signal_handler_add(proxy, "NewAttentionIcon", + s = eldbus_proxy_signal_handler_add(proxy, "NewAttentionIcon", new_attention_icon_cb, item); item->signals = eina_list_append(item->signals, s); - s = edbus_proxy_signal_handler_add(proxy, "NewIcon", + s = eldbus_proxy_signal_handler_add(proxy, "NewIcon", new_icon_cb, item); item->signals = eina_list_append(item->signals, s); - s = edbus_proxy_signal_handler_add(proxy, "NewIconThemePath", + s = eldbus_proxy_signal_handler_add(proxy, "NewIconThemePath", new_icon_theme_path_cb, item); item->signals = eina_list_append(item->signals, s); - s = edbus_proxy_signal_handler_add(proxy, "NewStatus", new_status_cb, item); + s = eldbus_proxy_signal_handler_add(proxy, "NewStatus", new_status_cb, item); item->signals = eina_list_append(item->signals, s); - s = edbus_proxy_signal_handler_add(proxy, "NewTitle", new_title_cb, item); + s = eldbus_proxy_signal_handler_add(proxy, "NewTitle", new_title_cb, item); item->signals = eina_list_append(item->signals, s); } static void -notifier_item_add_cb(void *data, const EDBus_Message *msg) +notifier_item_add_cb(void *data, const Eldbus_Message *msg) { const char *item, *bus, *path; Context_Notifier_Host *ctx = data; - if (!edbus_message_arguments_get(msg, "s", &item)) + if (!eldbus_message_arguments_get(msg, "s", &item)) { ERR("Error getting arguments from msg."); return; @@ -317,13 +317,13 @@ notifier_item_add_cb(void *data, const EDBus_Message *msg) } static void -notifier_item_del_cb(void *data, const EDBus_Message *msg) +notifier_item_del_cb(void *data, const Eldbus_Message *msg) { const char *service, *bus, *path; Notifier_Item *item; Context_Notifier_Host *ctx = data; - if (!edbus_message_arguments_get(msg, "s", &service)) + if (!eldbus_message_arguments_get(msg, "s", &service)) { ERR("Error getting arguments from msg."); return; @@ -339,32 +339,32 @@ notifier_item_del_cb(void *data, const EDBus_Message *msg) } static void -notifier_items_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UNUSED) +notifier_items_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { const char *item; const char *error, *error_msg; - EDBus_Message_Iter *array, *variant; + Eldbus_Message_Iter *array, *variant; Context_Notifier_Host *ctx = data; - if (edbus_message_error_get(msg, &error, &error_msg)) + if (eldbus_message_error_get(msg, &error, &error_msg)) { ERR("%s %s", error, error_msg); return; } - if (!edbus_message_arguments_get(msg, "v", &variant)) + if (!eldbus_message_arguments_get(msg, "v", &variant)) { ERR("Error getting arguments from msg."); return; } - if (!edbus_message_iter_arguments_get(variant, "as", &array)) + if (!eldbus_message_iter_arguments_get(variant, "as", &array)) { ERR("Error getting arguments from msg."); return; } - while (edbus_message_iter_get_and_next(array, 's', &item)) + while (eldbus_message_iter_get_and_next(array, 's', &item)) { const char *bus, *path; if (service_string_parse(item, &path, &bus)) @@ -398,27 +398,27 @@ item_unregistered_local_cb(void *data, const char *service) } static void -name_request_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) +name_request_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) { const char *error, *error_msg; unsigned flag; - EDBus_Object *obj; + Eldbus_Object *obj; Context_Notifier_Host *ctx = data; ctx->pending = eina_list_remove(ctx->pending, pending); - if (edbus_message_error_get(msg, &error, &error_msg)) + if (eldbus_message_error_get(msg, &error, &error_msg)) { ERR("%s %s", error, error_msg); goto end; } - if (!edbus_message_arguments_get(msg, "u", &flag)) + if (!eldbus_message_arguments_get(msg, "u", &flag)) { ERR("Error reading message."); goto end; } - if (flag == EDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER) + if (flag == ELDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER) { systray_notifier_dbus_watcher_start(ctx->conn, item_registered_local_cb, @@ -427,28 +427,28 @@ name_request_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) } end: WRN("Bus name: %s already in use, getting data via dbus.\n", WATCHER_BUS); - obj = edbus_object_get(ctx->conn, WATCHER_BUS, WATCHER_PATH); - ctx->watcher = edbus_proxy_get(obj, WATCHER_IFACE); - edbus_proxy_call(ctx->watcher, "RegisterStatusNotifierHost", NULL, NULL, -1, "s", + obj = eldbus_object_get(ctx->conn, WATCHER_BUS, WATCHER_PATH); + ctx->watcher = eldbus_proxy_get(obj, WATCHER_IFACE); + eldbus_proxy_call(ctx->watcher, "RegisterStatusNotifierHost", NULL, NULL, -1, "s", HOST_REGISTRER); - edbus_proxy_property_get(ctx->watcher, "RegisteredStatusNotifierItems", + eldbus_proxy_property_get(ctx->watcher, "RegisteredStatusNotifierItems", notifier_items_get_cb, ctx); - edbus_proxy_signal_handler_add(ctx->watcher, "StatusNotifierItemRegistered", + eldbus_proxy_signal_handler_add(ctx->watcher, "StatusNotifierItemRegistered", notifier_item_add_cb, ctx); - edbus_proxy_signal_handler_add(ctx->watcher, "StatusNotifierItemUnregistered", + eldbus_proxy_signal_handler_add(ctx->watcher, "StatusNotifierItemUnregistered", notifier_item_del_cb, ctx); } void systray_notifier_dbus_init(Context_Notifier_Host *ctx) { - EDBus_Pending *p; + Eldbus_Pending *p; - edbus_init(); - ctx->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); + eldbus_init(); + ctx->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); if (!ctx->conn) return; - p = edbus_name_request(ctx->conn, - WATCHER_BUS, EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, + p = eldbus_name_request(ctx->conn, + WATCHER_BUS, ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, name_request_cb, ctx); if (p) ctx->pending = eina_list_append(ctx->pending, p); } @@ -467,12 +467,12 @@ void systray_notifier_dbus_shutdown(Context_Notifier_Host *ctx) systray_notifier_dbus_watcher_stop(); else { - EDBus_Object *obj; - obj = edbus_proxy_object_get(ctx->watcher); - edbus_proxy_unref(ctx->watcher); - edbus_object_unref(obj); + Eldbus_Object *obj; + obj = eldbus_proxy_object_get(ctx->watcher); + eldbus_proxy_unref(ctx->watcher); + eldbus_object_unref(obj); ctx->watcher = NULL; } - edbus_connection_unref(ctx->conn); - edbus_shutdown(); + eldbus_connection_unref(ctx->conn); + eldbus_shutdown(); } diff --git a/src/modules/systray/e_mod_notifier_host_private.h b/src/modules/systray/e_mod_notifier_host_private.h index 0b00377b0..359ec020d 100644 --- a/src/modules/systray/e_mod_notifier_host_private.h +++ b/src/modules/systray/e_mod_notifier_host_private.h @@ -33,8 +33,8 @@ struct _Instance_Notifier_Host struct _Context_Notifier_Host { - EDBus_Connection *conn; - EDBus_Proxy *watcher; + Eldbus_Connection *conn; + Eldbus_Proxy *watcher; Eina_Inlist *item_list; Eina_Inlist *instances; Eina_List *pending; @@ -45,7 +45,7 @@ struct _Notifier_Item EINA_INLIST; const char *bus_id; const char *path; - EDBus_Proxy *proxy; + Eldbus_Proxy *proxy; Category category; Status status; E_DBusMenu_Item *dbus_item; @@ -69,5 +69,5 @@ void systray_notifier_item_free(Notifier_Item *item); void systray_notifier_dbus_init(Context_Notifier_Host *ctx); void systray_notifier_dbus_shutdown(Context_Notifier_Host *ctx); -void systray_notifier_dbus_watcher_start(EDBus_Connection *connection, E_Notifier_Watcher_Item_Registered_Cb registered, E_Notifier_Watcher_Item_Unregistered_Cb unregistered, const void *data); +void systray_notifier_dbus_watcher_start(Eldbus_Connection *connection, E_Notifier_Watcher_Item_Registered_Cb registered, E_Notifier_Watcher_Item_Unregistered_Cb unregistered, const void *data); void systray_notifier_dbus_watcher_stop(void); diff --git a/src/modules/systray/e_mod_notifier_watcher.c b/src/modules/systray/e_mod_notifier_watcher.c index b96180dda..322145bda 100644 --- a/src/modules/systray/e_mod_notifier_watcher.c +++ b/src/modules/systray/e_mod_notifier_watcher.c @@ -7,8 +7,8 @@ #define ERROR_HOST_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Host.AlreadyRegistered" #define ERROR_ITEM_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Item.AlreadyRegistered" -static EDBus_Connection *conn = NULL; -static EDBus_Service_Interface *iface = NULL; +static Eldbus_Connection *conn = NULL; +static Eldbus_Service_Interface *iface = NULL; static Eina_List *items; static const char *host_service = NULL; static E_Notifier_Watcher_Item_Registered_Cb registered_cb; @@ -31,40 +31,40 @@ item_name_monitor_cb(void *data, const char *bus, const char *old_id EINA_UNUSED if (strcmp(new_id, "")) return; - edbus_service_signal_emit(iface, ITEM_UNREGISTERED, service); + eldbus_service_signal_emit(iface, ITEM_UNREGISTERED, service); items = eina_list_remove(items, service); if (unregistered_cb) unregistered_cb(user_data, service); eina_stringshare_del(service); - edbus_name_owner_changed_callback_del(conn, bus, item_name_monitor_cb, service); + eldbus_name_owner_changed_callback_del(conn, bus, item_name_monitor_cb, service); } -static EDBus_Message * -register_item_cb(const EDBus_Service_Interface *s_iface, const EDBus_Message *msg) +static Eldbus_Message * +register_item_cb(const Eldbus_Service_Interface *s_iface, const Eldbus_Message *msg) { const char *service; char buf[1024]; - if (!edbus_message_arguments_get(msg, "s", &service)) + if (!eldbus_message_arguments_get(msg, "s", &service)) return NULL; - sprintf(buf, "%s%s", edbus_message_sender_get(msg), service); + sprintf(buf, "%s%s", eldbus_message_sender_get(msg), service); service = eina_stringshare_add(buf); if (eina_list_data_find(items, service)) { eina_stringshare_del(service); - return edbus_message_error_new(msg, ERROR_ITEM_ALREADY_REGISTERED, ""); + return eldbus_message_error_new(msg, ERROR_ITEM_ALREADY_REGISTERED, ""); } items = eina_list_append(items, service); - edbus_service_signal_emit(s_iface, ITEM_REGISTERED, service); - edbus_name_owner_changed_callback_add(conn, edbus_message_sender_get(msg), + eldbus_service_signal_emit(s_iface, ITEM_REGISTERED, service); + eldbus_name_owner_changed_callback_add(conn, eldbus_message_sender_get(msg), item_name_monitor_cb, service, EINA_FALSE); if (registered_cb) registered_cb(user_data, service); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } static void @@ -73,50 +73,50 @@ host_name_monitor_cb(void *data EINA_UNUSED, const char *bus, const char *old_id if (strcmp(new_id, "")) return; - edbus_service_signal_emit(iface, HOST_UNREGISTERED); + eldbus_service_signal_emit(iface, HOST_UNREGISTERED); eina_stringshare_del(host_service); host_service = NULL; - edbus_name_owner_changed_callback_del(conn, bus, host_name_monitor_cb, NULL); + eldbus_name_owner_changed_callback_del(conn, bus, host_name_monitor_cb, NULL); } -static EDBus_Message * -register_host_cb(const EDBus_Service_Interface *s_iface, const EDBus_Message *msg) +static Eldbus_Message * +register_host_cb(const Eldbus_Service_Interface *s_iface, const Eldbus_Message *msg) { if (host_service) - return edbus_message_error_new(msg, ERROR_HOST_ALREADY_REGISTERED, ""); + return eldbus_message_error_new(msg, ERROR_HOST_ALREADY_REGISTERED, ""); - if (!edbus_message_arguments_get(msg, "s", &host_service)) + if (!eldbus_message_arguments_get(msg, "s", &host_service)) return NULL; host_service = eina_stringshare_add(host_service); - edbus_service_signal_emit(s_iface, HOST_REGISTERED); - edbus_name_owner_changed_callback_add(conn, edbus_message_sender_get(msg), + eldbus_service_signal_emit(s_iface, HOST_REGISTERED); + eldbus_name_owner_changed_callback_add(conn, eldbus_message_sender_get(msg), host_name_monitor_cb, NULL, EINA_FALSE); - return edbus_message_method_return_new(msg); + return eldbus_message_method_return_new(msg); } static Eina_Bool -properties_get(const EDBus_Service_Interface *s_iface EINA_UNUSED, const char *propname, EDBus_Message_Iter *iter, const EDBus_Message *request_msg EINA_UNUSED, EDBus_Message **error EINA_UNUSED) +properties_get(const Eldbus_Service_Interface *s_iface EINA_UNUSED, const char *propname, Eldbus_Message_Iter *iter, const Eldbus_Message *request_msg EINA_UNUSED, Eldbus_Message **error EINA_UNUSED) { if (!strcmp(propname, "ProtocolVersion")) - edbus_message_iter_basic_append(iter, 'i', PROTOCOL_VERSION); + eldbus_message_iter_basic_append(iter, 'i', PROTOCOL_VERSION); else if (!strcmp(propname, "RegisteredStatusNotifierItems")) { - EDBus_Message_Iter *array; + Eldbus_Message_Iter *array; Eina_List *l; const char *service; - edbus_message_iter_arguments_append(iter, "as", &array); + eldbus_message_iter_arguments_append(iter, "as", &array); EINA_LIST_FOREACH(items, l, service) - edbus_message_iter_arguments_append(array, "s", service); - edbus_message_iter_container_close(iter, array); + eldbus_message_iter_arguments_append(array, "s", service); + eldbus_message_iter_container_close(iter, array); } else if (!strcmp(propname, "IsStatusNotifierHostRegistered")) - edbus_message_iter_arguments_append(iter, "b", host_service ? EINA_TRUE : EINA_FALSE); + eldbus_message_iter_arguments_append(iter, "b", host_service ? EINA_TRUE : EINA_FALSE); return EINA_TRUE; } -static const EDBus_Property properties[] = +static const Eldbus_Property properties[] = { { "RegisteredStatusNotifierItems", "as" }, { "IsStatusNotifierHostRegistered", "b" }, @@ -124,33 +124,33 @@ static const EDBus_Property properties[] = { } }; -static const EDBus_Signal signals[] = { - { "StatusNotifierItemRegistered", EDBUS_ARGS({"s", "service"}) }, - { "StatusNotifierItemUnregistered", EDBUS_ARGS({"s", "service"}) }, +static const Eldbus_Signal signals[] = { + { "StatusNotifierItemRegistered", ELDBUS_ARGS({"s", "service"}) }, + { "StatusNotifierItemUnregistered", ELDBUS_ARGS({"s", "service"}) }, { "StatusNotifierHostRegistered", NULL }, { "StatusNotifierHostUnregistered", NULL }, { } }; -static const EDBus_Method methods[] = +static const Eldbus_Method methods[] = { - { "RegisterStatusNotifierItem", EDBUS_ARGS({"s", "service"}), NULL, + { "RegisterStatusNotifierItem", ELDBUS_ARGS({"s", "service"}), NULL, register_item_cb }, - { "RegisterStatusNotifierHost", EDBUS_ARGS({"s", "service"}), NULL, + { "RegisterStatusNotifierHost", ELDBUS_ARGS({"s", "service"}), NULL, register_host_cb }, { } }; -static const EDBus_Service_Interface_Desc iface_desc = { +static const Eldbus_Service_Interface_Desc iface_desc = { IFACE, methods, signals, properties, properties_get, NULL }; void -systray_notifier_dbus_watcher_start(EDBus_Connection *connection, E_Notifier_Watcher_Item_Registered_Cb registered, E_Notifier_Watcher_Item_Unregistered_Cb unregistered, const void *data) +systray_notifier_dbus_watcher_start(Eldbus_Connection *connection, E_Notifier_Watcher_Item_Registered_Cb registered, E_Notifier_Watcher_Item_Unregistered_Cb unregistered, const void *data) { EINA_SAFETY_ON_TRUE_RETURN(!!conn); conn = connection; - iface = edbus_service_interface_register(conn, PATH, &iface_desc); + iface = eldbus_service_interface_register(conn, PATH, &iface_desc); registered_cb = registered; unregistered_cb = unregistered; user_data = (void *)data; @@ -162,7 +162,7 @@ systray_notifier_dbus_watcher_stop(void) { const char *txt; - edbus_service_interface_unregister(iface); + eldbus_service_interface_unregister(iface); EINA_LIST_FREE(items, txt) { char *bus; @@ -172,7 +172,7 @@ systray_notifier_dbus_watcher_stop(void) i++; bus = malloc(sizeof(char) * i); snprintf(bus, i, "%s", txt); - edbus_name_owner_changed_callback_del(conn, bus, item_name_monitor_cb, txt); + eldbus_name_owner_changed_callback_del(conn, bus, item_name_monitor_cb, txt); free(bus); eina_stringshare_del(txt); } diff --git a/src/modules/wizard/page_110.c b/src/modules/wizard/page_110.c index 8a9a7b7f4..e8ff69eac 100644 --- a/src/modules/wizard/page_110.c +++ b/src/modules/wizard/page_110.c @@ -1,7 +1,7 @@ /* Setup if we need connman? */ #include "e_wizard.h" #ifdef HAVE_ECONNMAN -#include +#include #endif static void @@ -38,8 +38,8 @@ _recommend_connman(E_Wizard_Page *pg) e_wizard_button_next_enable_set(1); } -static EDBus_Connection *conn; -static EDBus_Pending *pending_connman; +static Eldbus_Connection *conn; +static Eldbus_Pending *pending_connman; static Ecore_Timer *connman_timeout = NULL; static Eina_Bool @@ -77,8 +77,8 @@ _page_next_call(void *data EINA_UNUSED) } static void -_check_connman_owner(void *data, const EDBus_Message *msg, - EDBus_Pending *pending __UNUSED__) +_check_connman_owner(void *data, const Eldbus_Message *msg, + Eldbus_Pending *pending __UNUSED__) { const char *id; pending_connman = NULL; @@ -89,10 +89,10 @@ _check_connman_owner(void *data, const EDBus_Message *msg, connman_timeout = NULL; } - if (edbus_message_error_get(msg, NULL, NULL)) + if (eldbus_message_error_get(msg, NULL, NULL)) goto fail; - if (!edbus_message_arguments_get(msg, "s", &id)) + if (!eldbus_message_arguments_get(msg, "s", &id)) goto fail; if (id[0] != ':') @@ -124,15 +124,15 @@ wizard_page_show(E_Wizard_Page *pg) Eina_Bool have_connman = EINA_FALSE; #ifdef HAVE_ECONNMAN - edbus_init(); - conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); + eldbus_init(); + conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); #endif if (conn) { if (pending_connman) - edbus_pending_cancel(pending_connman); + eldbus_pending_cancel(pending_connman); - pending_connman = edbus_name_owner_get(conn, "net.connman", + pending_connman = eldbus_name_owner_get(conn, "net.connman", _check_connman_owner, pg); if (connman_timeout) ecore_timer_del(connman_timeout); @@ -168,7 +168,7 @@ wizard_page_hide(E_Wizard_Page *pg __UNUSED__) { if (pending_connman) { - edbus_pending_cancel(pending_connman); + eldbus_pending_cancel(pending_connman); pending_connman = NULL; } if (connman_timeout) @@ -177,11 +177,11 @@ wizard_page_hide(E_Wizard_Page *pg __UNUSED__) connman_timeout = NULL; } if (conn) - edbus_connection_unref(conn); + eldbus_connection_unref(conn); conn = NULL; #ifdef HAVE_ECONNMAN - edbus_shutdown(); + eldbus_shutdown(); #endif return 1;