enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 25 Pull Requests 2 Projects Releases Wiki Activity

Rename edbus->eldbus

This commit is contained in:
Lucas De Marchi 2013-04-23 12:08:29 -03:00
parent 646943d897
commit f8a2dd4d95
52 changed files with 2796 additions and 2796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -303,9 +303,9 @@
2013-01-03 José Roberto de Souza 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 illume-indicator
* Fileman and Wizard also ported to edbus * Fileman and Wizard also ported to eldbus
* HAL backend for EFM removed * HAL backend for EFM removed
* Systray: added DBus notification * Systray: added DBus notification
* Added music-control module: control any mpris2-compatible music * Added music-control module: control any mpris2-compatible music

16
configure.ac
View File

@ -467,7 +467,7 @@ ecore-file >= $efl_version \
ecore-ipc >= $efl_version \ ecore-ipc >= $efl_version \
eet >= $efl_version \ eet >= $efl_version \
efreet >= $efl_version \ efreet >= $efl_version \
edbus2 >= $efl_version \ eldbus >= $efl_version \
eina >= $efl_version" eina >= $efl_version"
efm_requires="$efm_requires $eeze_mount $dbus_mount $udisks_mount" efm_requires="$efm_requires $eeze_mount $dbus_mount $udisks_mount"
@ -477,7 +477,7 @@ PKG_CHECK_MODULES(E_FM_CMDLINE, [
eina >= ${efl_version} eina >= ${efl_version}
ecore >= ${efl_version} ecore >= ${efl_version}
ecore-file >= ${efl_version} ecore-file >= ${efl_version}
edbus2 >= ${efl_version} eldbus >= ${efl_version}
efreet >= ${efl_version} efreet >= ${efl_version}
]) ])
@ -535,7 +535,7 @@ PKG_CHECK_MODULES(E, [
efreet-mime >= ${efl_version} efreet-mime >= ${efl_version}
efreet-trash >= ${efl_version} efreet-trash >= ${efl_version}
eina >= ${efl_version} eina >= ${efl_version}
edbus2 >= ${efl_version} eldbus >= ${efl_version}
eio >= ${efl_version} eio >= ${efl_version}
$eeze_mount $eeze_mount
$udisks_mount $udisks_mount
@ -555,7 +555,7 @@ efreet >= ${efl_version} \
efreet-mime >= ${efl_version} \ efreet-mime >= ${efl_version} \
efreet-trash >= ${efl_version} \ efreet-trash >= ${efl_version} \
eina >= ${efl_version} \ eina >= ${efl_version} \
edbus2 \ eldbus \
eio >= ${efl_version} \ eio >= ${efl_version} \
$udisks_mount \ $udisks_mount \
$eeze_mount \ $eeze_mount \
@ -688,7 +688,7 @@ define([CHECK_MODULE_TEMPERATURE],
AM_CONDITIONAL(MUSIC_CONTROL, false) AM_CONDITIONAL(MUSIC_CONTROL, false)
define([CHECK_MODULE_MUSIC_CONTROL], 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 ##have_exchange=no
@ -717,7 +717,7 @@ AC_ARG_ENABLE([enotify],
AC_CACHE_VAL([e_cv_want_enotify], [e_cv_want_enotify=yes]) AC_CACHE_VAL([e_cv_want_enotify], [e_cv_want_enotify=yes])
) )
if test "x$e_cv_want_enotify" != "xno" ; then 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]) AC_DEFINE_UNQUOTED([HAVE_ENOTIFY], [1], [enable enotify])
], ],
@ -803,7 +803,7 @@ AM_CONDITIONAL(HAVE_ECONNMAN, false)
AM_CONDITIONAL(HAVE_DUMMY, false) AM_CONDITIONAL(HAVE_DUMMY, false)
define([CHECK_MODULE_CONNMAN], 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]) dnl AC_E_CHECK_PKG(DUMMY, [ connman >= 1.0 ], [], [CONNMAN=false])
]) ])
AC_SUBST(ECONNMAN_CFLAGS) AC_SUBST(ECONNMAN_CFLAGS)
@ -813,7 +813,7 @@ AM_CONDITIONAL(HAVE_BLUEZ4, false)
AM_CONDITIONAL(HAVE_DUMMY, false) AM_CONDITIONAL(HAVE_DUMMY, false)
define([CHECK_MODULE_BLUEZ4], define([CHECK_MODULE_BLUEZ4],
[ [
AC_E_CHECK_PKG(BLUEZ4, [ edbus2 ],) AC_E_CHECK_PKG(BLUEZ4, [ eldbus ],)
]) ])
AC_SUBST(EBLUEZ4_CFLAGS) AC_SUBST(EBLUEZ4_CFLAGS)
AC_SUBST(EBLUEZ4_LIBS) AC_SUBST(EBLUEZ4_LIBS)

2
src/bin/e.h
View File

@ -114,7 +114,7 @@ void *alloca (size_t);
# include <Efreet.h> # include <Efreet.h>
# include <Efreet_Mime.h> # include <Efreet_Mime.h>
# include <Edje.h> # include <Edje.h>
# include <EDBus.h> # include <Eldbus.h>
# include <Eio.h> # include <Eio.h>
# ifdef HAVE_HAL # ifdef HAVE_HAL

146
src/bin/e_dbusmenu.c
View File

@ -4,7 +4,7 @@
struct _E_DBusMenu_Ctx struct _E_DBusMenu_Ctx
{ {
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
E_DBusMenu_Item *root_menu; E_DBusMenu_Item *root_menu;
void *data; void *data;
E_DBusMenu_Pop_Request_Cb pop_request_cb; 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 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; E_DBusMenu_Item *m = data;
if (!strcmp(key, "label")) 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(); Eina_Strbuf *label_buf = eina_strbuf_new();
int i; int i;
edbus_message_iter_arguments_get(var, "s", &label); eldbus_message_iter_arguments_get(var, "s", &label);
for (i = 0; label[i]; i++) for (i = 0; label[i]; i++)
{ {
if (label[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")) else if (!strcmp(key, "type"))
{ {
const char *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); m->type = id_find(type, Menu_Item_Type_Names, E_DBUSMENU_ITEM_TYPE_LAST);
} }
else if (!strcmp(key, "icon-data")) else if (!strcmp(key, "icon-data"))
{ {
EDBus_Message_Iter *array; Eldbus_Message_Iter *array;
int size; int size;
const unsigned char *img_data; const unsigned char *img_data;
edbus_message_iter_arguments_get(var, "ay", &array); eldbus_message_iter_arguments_get(var, "ay", &array);
edbus_message_iter_fixed_array_get(array, 'y', &img_data, &size); eldbus_message_iter_fixed_array_get(array, 'y', &img_data, &size);
if (!size) if (!size)
return; return;
m->icon_data = malloc(sizeof(unsigned char) * size); 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")) else if (!strcmp(key, "icon-name"))
{ {
const char *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); eina_stringshare_replace(&m->icon_name, icon_name);
} }
else if (!strcmp(key, "toggle-type")) else if (!strcmp(key, "toggle-type"))
{ {
const char *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, m->toggle_type = id_find(toggle_type, Menu_Item_Toggle_Type_Names,
E_DBUSMENU_ITEM_TOGGLE_TYPE_LAST); E_DBUSMENU_ITEM_TOGGLE_TYPE_LAST);
} }
else if (!strcmp(key, "toggle-state")) else if (!strcmp(key, "toggle-state"))
{ {
int state; int state;
edbus_message_iter_arguments_get(var, "i", &state); eldbus_message_iter_arguments_get(var, "i", &state);
if (state == 1) if (state == 1)
m->toggle_state = EINA_TRUE; m->toggle_state = EINA_TRUE;
else 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")) else if (!strcmp(key, "children-display"))
{ {
const char *display; const char *display;
edbus_message_iter_arguments_get(var, "s", &display); eldbus_message_iter_arguments_get(var, "s", &display);
if (!strcmp(display, "submenu")) if (!strcmp(display, "submenu"))
m->is_submenu = EINA_TRUE; m->is_submenu = EINA_TRUE;
else else
@ -128,27 +128,27 @@ dbus_menu_prop_dict_cb(void *data, const void *key, EDBus_Message_Iter *var)
else if (!strcmp(key, "disposition")) else if (!strcmp(key, "disposition"))
{ {
const char *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, m->disposition = id_find(disposition, Menu_Item_Dispostion_Names,
E_DBUSMENU_ITEM_DISPOSTION_LAST); E_DBUSMENU_ITEM_DISPOSTION_LAST);
} }
else if (!strcmp(key, "enabled")) 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")) 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 * 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)); E_DBusMenu_Item *m = calloc(1, sizeof(E_DBusMenu_Item));
EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL);
m->ctx = ctx; m->ctx = ctx;
m->enabled = EINA_TRUE; m->enabled = EINA_TRUE;
m->visible = 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)) &menu_item_prop, &sub_menu_items_prop))
{ {
ERR("Error reading message"); ERR("Error reading message");
@ -156,12 +156,12 @@ parse_layout(EDBus_Message_Iter *layout, E_DBusMenu_Item *parent, E_DBusMenu_Ctx
return NULL; 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; Eldbus_Message_Iter *st;
if (!edbus_message_iter_arguments_get(var, "(ia{sv}av)", &st)) if (!eldbus_message_iter_arguments_get(var, "(ia{sv}av)", &st))
{ {
ERR("Error readding message."); ERR("Error readding message.");
continue; continue;
@ -198,21 +198,21 @@ dbus_menu_free(E_DBusMenu_Item *m)
} }
static void 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; E_DBusMenu_Item *m;
const char *error, *error_msg; const char *error, *error_msg;
EDBus_Message_Iter *layout; Eldbus_Message_Iter *layout;
unsigned revision; unsigned revision;
E_DBusMenu_Ctx *ctx = data; 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); ERR("%s %s", error, error_msg);
return; 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"); ERR("Error reading message");
return; return;
@ -250,14 +250,14 @@ dbus_menu_find(E_DBusMenu_Ctx *ctx, int id)
} }
static void 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; E_DBusMenu_Ctx *ctx = data;
int id; int id;
unsigned timestamp; unsigned timestamp;
E_DBusMenu_Item *m; E_DBusMenu_Item *m;
if (!edbus_message_arguments_get(msg, "iu", &id, &timestamp)) if (!eldbus_message_arguments_get(msg, "iu", &id, &timestamp))
{ {
ERR("Error reading values."); ERR("Error reading values.");
return; return;
@ -271,38 +271,38 @@ menu_pop_request(void *data, const EDBus_Message *msg)
} }
static void 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; const char *error, *error_msg;
EDBus_Message_Iter *var, *array; Eldbus_Message_Iter *var, *array;
const char *path; 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); ERR("%s %s", error, error_msg);
return; return;
} }
if (!edbus_message_arguments_get(msg, "v", &var) || if (!eldbus_message_arguments_get(msg, "v", &var) ||
!edbus_message_iter_arguments_get(var, "as", &array)) !eldbus_message_iter_arguments_get(var, "as", &array))
{ {
ERR("Error reading message."); ERR("Error reading message.");
return; return;
} }
while (edbus_message_iter_get_and_next(array, 's', &path)) while (eldbus_message_iter_get_and_next(array, 's', &path))
{ {
//TODO //TODO
} }
} }
static void 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; 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"); ERR("Error getting values");
return; return;
@ -311,7 +311,7 @@ prop_changed_cb(void *data EINA_UNUSED, const EDBus_Message *msg)
if (strcmp(propname, "IconThemePath")) if (strcmp(propname, "IconThemePath"))
return; return;
if (!edbus_message_iter_arguments_get(variant, "as", &array)) if (!eldbus_message_iter_arguments_get(variant, "as", &array))
{ {
//TODO //TODO
} }
@ -320,27 +320,27 @@ prop_changed_cb(void *data EINA_UNUSED, const EDBus_Message *msg)
static void static void
layout_update(E_DBusMenu_Ctx *ctx) layout_update(E_DBusMenu_Ctx *ctx)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *main_iter, *array; Eldbus_Message_Iter *main_iter, *array;
msg = edbus_proxy_method_call_new(ctx->proxy, "GetLayout"); msg = eldbus_proxy_method_call_new(ctx->proxy, "GetLayout");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_arguments_append(main_iter, "iias", 0, -1, &array); eldbus_message_iter_arguments_append(main_iter, "iias", 0, -1, &array);
edbus_message_iter_container_close(main_iter, array); eldbus_message_iter_container_close(main_iter, array);
edbus_proxy_send(ctx->proxy, msg, layout_get_cb, ctx, -1); eldbus_proxy_send(ctx->proxy, msg, layout_get_cb, ctx, -1);
} }
static void 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; E_DBusMenu_Ctx *ctx = data;
layout_update(ctx); layout_update(ctx);
} }
EAPI E_DBusMenu_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; E_DBusMenu_Ctx *ctx;
EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, 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; ctx->data = (void *)data;
edbus_connection_ref(conn); eldbus_connection_ref(conn);
obj = edbus_object_get(conn, bus, path); obj = eldbus_object_get(conn, bus, path);
ctx->proxy = edbus_proxy_get(obj, DBUS_MENU_IFACE); ctx->proxy = eldbus_proxy_get(obj, DBUS_MENU_IFACE);
layout_update(ctx); layout_update(ctx);
edbus_proxy_signal_handler_add(ctx->proxy, eldbus_proxy_signal_handler_add(ctx->proxy,
"ItemActivationRequested", "ItemActivationRequested",
menu_pop_request, ctx); menu_pop_request, ctx);
edbus_proxy_property_get(ctx->proxy, "IconThemePath", eldbus_proxy_property_get(ctx->proxy, "IconThemePath",
icon_theme_path_get_cb, ctx); 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); prop_changed_cb, ctx);
edbus_proxy_signal_handler_add(ctx->proxy, "ItemsPropertiesUpdated", eldbus_proxy_signal_handler_add(ctx->proxy, "ItemsPropertiesUpdated",
layout_updated_cb, ctx); layout_updated_cb, ctx);
edbus_proxy_signal_handler_add(ctx->proxy, "LayoutUpdated", eldbus_proxy_signal_handler_add(ctx->proxy, "LayoutUpdated",
layout_updated_cb, ctx); layout_updated_cb, ctx);
return ctx; return ctx;
} }
@ -374,44 +374,44 @@ e_dbusmenu_load(EDBus_Connection *conn, const char *bus, const char *path, const
EAPI void EAPI void
e_dbusmenu_event_send(E_DBusMenu_Item *m, E_DBusMenu_Item_Event event) e_dbusmenu_event_send(E_DBusMenu_Item *m, E_DBusMenu_Item_Event event)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *main_iter, *var; Eldbus_Message_Iter *main_iter, *var;
unsigned int timestamp = (unsigned int)time(NULL); unsigned int timestamp = (unsigned int)time(NULL);
EINA_SAFETY_ON_NULL_RETURN(m); EINA_SAFETY_ON_NULL_RETURN(m);
EINA_SAFETY_ON_FALSE_RETURN(event < E_DBUSMENU_ITEM_EVENT_LAST); EINA_SAFETY_ON_FALSE_RETURN(event < E_DBUSMENU_ITEM_EVENT_LAST);
EINA_SAFETY_ON_NULL_RETURN(m->ctx); EINA_SAFETY_ON_NULL_RETURN(m->ctx);
msg = edbus_proxy_method_call_new(m->ctx->proxy, "Event"); msg = eldbus_proxy_method_call_new(m->ctx->proxy, "Event");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_arguments_append(main_iter, "is", m->id, eldbus_message_iter_arguments_append(main_iter, "is", m->id,
Menu_Item_Event_Names[event]); 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 */ /* dummy data */
edbus_message_iter_arguments_append(var, "s", ""); eldbus_message_iter_arguments_append(var, "s", "");
edbus_message_iter_container_close(main_iter, var); 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); eldbus_proxy_send(m->ctx->proxy, msg, NULL, NULL, -1);
edbus_message_unref(msg); eldbus_message_unref(msg);
} }
EAPI void EAPI void
e_dbusmenu_unload(E_DBusMenu_Ctx *ctx) e_dbusmenu_unload(E_DBusMenu_Ctx *ctx)
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Object *obj; Eldbus_Object *obj;
EINA_SAFETY_ON_NULL_RETURN(ctx); EINA_SAFETY_ON_NULL_RETURN(ctx);
if (ctx->root_menu) if (ctx->root_menu)
dbus_menu_free(ctx->root_menu); dbus_menu_free(ctx->root_menu);
obj = edbus_proxy_object_get(ctx->proxy); obj = eldbus_proxy_object_get(ctx->proxy);
conn = edbus_object_connection_get(obj); conn = eldbus_object_connection_get(obj);
edbus_proxy_unref(ctx->proxy); eldbus_proxy_unref(ctx->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
edbus_connection_unref(conn); eldbus_connection_unref(conn);
free(ctx); free(ctx);
} }

4
src/bin/e_dbusmenu.h
View File

@ -2,7 +2,7 @@
#define _E_DBUSMENU_H_ #define _E_DBUSMENU_H_
#include <Eina.h> #include <Eina.h>
#include <EDBus.h> #include <Eldbus.h>
typedef enum { typedef enum {
E_DBUSMENU_ITEM_TYPE_STANDARD = 0, 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_Pop_Request_Cb)(void *data, const E_DBusMenu_Item *item);
typedef void (*E_DBusMenu_Update_Cb)(void *data, E_DBusMenu_Item *new_root_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_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_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); EAPI void e_dbusmenu_pop_request_cb_set(E_DBusMenu_Ctx *menu_data, E_DBusMenu_Pop_Request_Cb cb);

2
src/bin/e_fm/e_fm_main.c
View File

@ -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: /* 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.) * * 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) * * 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)
* *
*/ */

336
src/bin/e_fm/e_fm_main_udisks.c
View File

@ -45,7 +45,7 @@ void *alloca(size_t);
#include <Ecore_Ipc.h> #include <Ecore_Ipc.h>
#include <Ecore_File.h> #include <Ecore_File.h>
#include <Eet.h> #include <Eet.h>
#include <EDBus.h> #include <Eldbus.h>
#include "e_fm_shared_device.h" #include "e_fm_shared_device.h"
#include "e_fm_shared_codec.h" #include "e_fm_shared_codec.h"
@ -60,22 +60,22 @@ void *alloca(size_t);
#define UDISKS_INTERFACE "org.freedesktop.UDisks" #define UDISKS_INTERFACE "org.freedesktop.UDisks"
#define UDISKS_DEVICE_INTERFACE "org.freedesktop.UDisks.Device" #define UDISKS_DEVICE_INTERFACE "org.freedesktop.UDisks.Device"
static EDBus_Connection *_e_fm_main_udisks_conn = NULL; static Eldbus_Connection *_e_fm_main_udisks_conn = NULL;
static EDBus_Proxy *_e_fm_main_udisks_proxy = NULL; static Eldbus_Proxy *_e_fm_main_udisks_proxy = NULL;
static Eina_List *_e_stores = NULL; static Eina_List *_e_stores = NULL;
static Eina_List *_e_vols = NULL; static Eina_List *_e_vols = NULL;
static void _e_fm_main_udisks_cb_dev_all(void *data, const EDBus_Message *msg, static void _e_fm_main_udisks_cb_dev_all(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending); Eldbus_Pending *pending);
static void _e_fm_main_udisks_cb_dev_verify(void *data, const EDBus_Message *msg, static void _e_fm_main_udisks_cb_dev_verify(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending); Eldbus_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_add(void *data, const Eldbus_Message *msg);
static void _e_fm_main_udisks_cb_dev_del(void *data, const EDBus_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 EDBus_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 EDBus_Message *msg, static void _e_fm_main_udisks_cb_store_prop(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending); Eldbus_Pending *pending);
static void _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, static void _e_fm_main_udisks_cb_vol_prop(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending); Eldbus_Pending *pending);
static void _e_fm_main_udisks_cb_vol_mounted(E_Volume *v); 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(E_Volume *v);
static void _e_fm_main_udisks_cb_vol_unmounted_before_eject(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 _volume_del(E_Volume *v);
static void static void
_e_fm_main_udisks_name_start(void *data __UNUSED__, const EDBus_Message *msg, _e_fm_main_udisks_name_start(void *data __UNUSED__, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
unsigned flag = 0; 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); _e_fm_main_udisks_catch(EINA_FALSE);
return; return;
} }
obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, UDISKS_PATH); obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, UDISKS_PATH);
_e_fm_main_udisks_proxy = edbus_proxy_get(obj, UDISKS_INTERFACE); _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, ""); _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); _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_cb_dev_del, NULL);
_e_fm_main_udisks_catch(EINA_TRUE); /* signal usage of udisks for mounting */ _e_fm_main_udisks_catch(EINA_TRUE); /* signal usage of udisks for mounting */
} }
static void static void
_e_fm_main_udisks_cb_dev_all(void *data __UNUSED__, const EDBus_Message *msg, _e_fm_main_udisks_cb_dev_all(void *data __UNUSED__, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
const char *name, *txt, *path; 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); ERR("Error %s %s.", name, txt);
return; return;
} }
if (!edbus_message_arguments_get(msg, "ao", &array)) if (!eldbus_message_arguments_get(msg, "ao", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
return; 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; Eldbus_Message *new_msg;
new_msg = edbus_message_method_call_new(UDISKS_BUS, path, new_msg = eldbus_message_method_call_new(UDISKS_BUS, path,
EDBUS_FDO_INTERFACE_PROPERTIES, "Get"); ELDBUS_FDO_INTERFACE_PROPERTIES, "Get");
edbus_message_arguments_append(new_msg, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); eldbus_message_arguments_append(new_msg, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage");
edbus_connection_send(_e_fm_main_udisks_conn, new_msg, eldbus_connection_send(_e_fm_main_udisks_conn, new_msg,
_e_fm_main_udisks_cb_dev_verify, _e_fm_main_udisks_cb_dev_verify,
eina_stringshare_add(path), -1); eina_stringshare_add(path), -1);
INF("DB INIT DEV+: %s", path); 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 static void
_e_fm_main_udisks_cb_dev_verify(void *data, const EDBus_Message *msg, _e_fm_main_udisks_cb_dev_verify(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
const char *name, *txt, *id_usage, *path = data; 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); ERR("Error %s %s.", name, txt);
goto error; goto error;
} }
if (!edbus_message_arguments_get(msg, "v", &variant)) if (!eldbus_message_arguments_get(msg, "v", &variant))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
goto error; 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"); ERR("Type of variant not expected");
goto error; goto error;
@ -189,25 +189,25 @@ error:
} }
static void static void
_e_fm_main_udisks_cb_dev_verify_added(void *data, const EDBus_Message *msg, _e_fm_main_udisks_cb_dev_verify_added(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
const char *name, *txt, *id_usage, *path = data; 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); ERR("Error %s %s.", name, txt);
goto error; goto error;
} }
if (!edbus_message_arguments_get(msg, "v", &variant)) if (!eldbus_message_arguments_get(msg, "v", &variant))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
goto error; 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"); ERR("Type of variant not expected");
goto error; goto error;
@ -221,7 +221,7 @@ _e_fm_main_udisks_cb_dev_verify_added(void *data, const EDBus_Message *msg,
if (!s) if (!s)
_e_fm_main_udisks_storage_add(path); _e_fm_main_udisks_storage_add(path);
else else
edbus_proxy_property_get_all(s->proxy, eldbus_proxy_property_get_all(s->proxy,
_e_fm_main_udisks_cb_store_prop, s); _e_fm_main_udisks_cb_store_prop, s);
} }
else if(!strcmp(id_usage, "filesystem")) 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) if (!v)
_e_fm_main_udisks_volume_add(path, EINA_TRUE); _e_fm_main_udisks_volume_add(path, EINA_TRUE);
else else
edbus_proxy_property_get_all(v->proxy, eldbus_proxy_property_get_all(v->proxy,
_e_fm_main_udisks_cb_vol_prop, v); _e_fm_main_udisks_cb_vol_prop, v);
} }
else else
@ -242,37 +242,37 @@ error:
} }
static void 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; E_Volume *v;
char *path; char *path;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
DBG("DB DEV+: %s", path); DBG("DB DEV+: %s", path);
v = _volume_find_by_dbus_path(path); v = _volume_find_by_dbus_path(path);
if (v) 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; return;
} }
new = edbus_message_method_call_new(UDISKS_BUS, path, EDBUS_FDO_INTERFACE_PROPERTIES, "Get"); new = eldbus_message_method_call_new(UDISKS_BUS, path, ELDBUS_FDO_INTERFACE_PROPERTIES, "Get");
edbus_message_arguments_append(new, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage"); eldbus_message_arguments_append(new, "ss", UDISKS_DEVICE_INTERFACE, "IdUsage");
edbus_connection_send(_e_fm_main_udisks_conn, new, eldbus_connection_send(_e_fm_main_udisks_conn, new,
_e_fm_main_udisks_cb_dev_verify_added, _e_fm_main_udisks_cb_dev_verify_added,
eina_stringshare_add(path), -1); eina_stringshare_add(path), -1);
} }
static void 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; char *path;
E_Volume *v; E_Volume *v;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
DBG("DB DEV-: %s", path); DBG("DB DEV-: %s", path);
if ((v = _volume_find_by_dbus_path(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 static void
_e_fm_main_udisks_cb_prop_modified(void *data, _e_fm_main_udisks_cb_prop_modified(void *data,
const EDBus_Message *msg __UNUSED__) const Eldbus_Message *msg __UNUSED__)
{ {
E_Volume *v = data; 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 static Eina_Bool
@ -301,41 +301,41 @@ _storage_del(void *data)
} }
static void static void
_e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg, _e_fm_main_udisks_cb_store_prop(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
E_Storage *s = data; E_Storage *s = data;
const char *name, *txt; 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); ERR("Error %s %s.", name, txt);
return; return;
} }
if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) if (!eldbus_message_arguments_get(msg, "a{sv}", &dict))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
return; return;
} }
while (edbus_message_iter_get_and_next(dict, 'e', &entry)) while (eldbus_message_iter_get_and_next(dict, 'e', &entry))
{ {
char *key; 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; continue;
if (!strcmp(key, "DeviceFile")) if (!strcmp(key, "DeviceFile"))
{ {
const char *udi; 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); eina_stringshare_replace(&s->udi, udi);
} }
else if (!strcmp(key, "DriveConnectionInterface")) else if (!strcmp(key, "DriveConnectionInterface"))
{ {
const char *bus; const char *bus;
if (edbus_message_iter_arguments_get(var, "s", &bus)) if (eldbus_message_iter_arguments_get(var, "s", &bus))
{ {
if (s->bus) if (s->bus)
eina_stringshare_del(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")) else if (!strcmp(key, "DriveMediaCompatibility"))
{ {
EDBus_Message_Iter *inner_array; Eldbus_Message_Iter *inner_array;
const char *media; const char *media;
if (!edbus_message_iter_arguments_get(var, "as", &inner_array)) if (!eldbus_message_iter_arguments_get(var, "as", &inner_array))
continue; 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); eina_stringshare_replace(&s->drive_type, media);
break; break;
@ -359,13 +359,13 @@ _e_fm_main_udisks_cb_store_prop(void *data, const EDBus_Message *msg,
else if (!strcmp(key, "DriveModel")) else if (!strcmp(key, "DriveModel"))
{ {
const char *model; 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); eina_stringshare_replace(&s->model, model);
} }
else if (!strcmp(key, "DriveVendor")) else if (!strcmp(key, "DriveVendor"))
{ {
const char *vendor; const char *vendor;
if (edbus_message_iter_arguments_get(var, "s", &vendor)) if (eldbus_message_iter_arguments_get(var, "s", &vendor))
{ {
if (s->vendor) if (s->vendor)
eina_stringshare_del(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")) else if (!strcmp(key, "DriveSerial"))
{ {
const char *serial; const char *serial;
if (edbus_message_iter_arguments_get(var, "s", &serial)) if (eldbus_message_iter_arguments_get(var, "s", &serial))
{ {
if (s->serial) if (s->serial)
eina_stringshare_del(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")) 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")) 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")) 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")) 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")) 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")) 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")) else if (!strcmp(key, "DevicePresentationIconName"))
{ {
const char *icon; 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) if (s->icon.drive)
eina_stringshare_del(s->icon.drive); eina_stringshare_del(s->icon.drive);
@ -450,39 +450,39 @@ _idler_volume_del(void *data)
} }
static void static void
_e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg, _e_fm_main_udisks_cb_vol_prop(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
E_Volume *v = data; E_Volume *v = data;
E_Storage *s = NULL; E_Storage *s = NULL;
const char *txt, *message; const char *txt, *message;
EDBus_Message_Iter *array, *dict; Eldbus_Message_Iter *array, *dict;
DBG("volume=%s",v->dbus_path); 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); ERR("Error: %s %s\nVolume: %s", txt, message, v->udi);
return; return;
} }
if (!edbus_message_arguments_get(msg, "a{sv}", &array)) if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
{ {
ERR("Error getting values."); ERR("Error getting values.");
return; 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; const char *key;
if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var))
continue; continue;
if (!strcmp(key, "DeviceFile")) if (!strcmp(key, "DeviceFile"))
{ {
const char *udi; const char *udi;
if (!edbus_message_iter_arguments_get(var, "s", &udi)) if (!eldbus_message_iter_arguments_get(var, "s", &udi))
continue; continue;
if (udi && v->first_time) if (udi && v->first_time)
eina_stringshare_replace(&v->udi, udi); 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")) else if (!strcmp(key, "DeviceIsSystemInternal"))
{ {
Eina_Bool internal; Eina_Bool internal;
edbus_message_iter_arguments_get(var, "b", &internal); eldbus_message_iter_arguments_get(var, "b", &internal);
if (internal) if (internal)
{ {
DBG("removing is internal %s", v->dbus_path); 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")) else if (!strcmp(key, "DeviceIsMediaChangeDetectionInhibited"))
{ {
Eina_Bool inibited; Eina_Bool inibited;
edbus_message_iter_arguments_get(var, "b", &inibited); eldbus_message_iter_arguments_get(var, "b", &inibited);
if (inibited) if (inibited)
{ {
/* skip volumes with volume.ignore set */ /* 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")) 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")) else if (!strcmp(key, "IdUuid"))
{ {
const char *uuid; const char *uuid;
if (!edbus_message_iter_arguments_get(var, "s", &uuid)) if (!eldbus_message_iter_arguments_get(var, "s", &uuid))
continue; continue;
eina_stringshare_replace(&v->uuid, uuid); eina_stringshare_replace(&v->uuid, uuid);
} }
else if (!strcmp(key, "IdLabel")) else if (!strcmp(key, "IdLabel"))
{ {
const char *label; const char *label;
if (!edbus_message_iter_arguments_get(var, "s", &label)) if (!eldbus_message_iter_arguments_get(var, "s", &label))
continue; continue;
eina_stringshare_replace(&v->label, label); eina_stringshare_replace(&v->label, label);
} }
else if (!strcmp(key, "DeviceMountPaths")) else if (!strcmp(key, "DeviceMountPaths"))
{ {
EDBus_Message_Iter *inner_array; Eldbus_Message_Iter *inner_array;
const char *path; const char *path;
if (!edbus_message_iter_arguments_get(var, "as", &inner_array)) if (!eldbus_message_iter_arguments_get(var, "as", &inner_array))
continue; 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); eina_stringshare_replace(&v->mount_point, path);
break; break;
@ -543,24 +543,24 @@ _e_fm_main_udisks_cb_vol_prop(void *data, const EDBus_Message *msg,
else if (!strcmp(key, "IdType")) else if (!strcmp(key, "IdType"))
{ {
const char *type; const char *type;
if (!edbus_message_iter_arguments_get(var, "s", &type)) if (!eldbus_message_iter_arguments_get(var, "s", &type))
continue; continue;
eina_stringshare_replace(&v->fstype, type); eina_stringshare_replace(&v->fstype, type);
} }
else if (!strcmp(key, "DeviceSize")) 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")) 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")) 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")) 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")) 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")) else if (!strcmp(key, "PartitionLabel"))
{ {
const char *partition_label; 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; continue;
eina_stringshare_replace(&v->partition_label, partition_label); 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; const char *enc;
E_Volume *venc; E_Volume *venc;
if (!edbus_message_iter_arguments_get(var, "o", &enc)) if (!eldbus_message_iter_arguments_get(var, "o", &enc))
continue; continue;
eina_stringshare_replace(&v->partition_label, enc); eina_stringshare_replace(&v->partition_label, enc);
venc = _e_fm_main_udisks_volume_find(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")) else if (!strcmp(key, "PartitionSlave"))
{ {
char *partition_slave, buf[4096]; 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; continue;
if ((!partition_slave) || (strlen(partition_slave) < sizeof("/org/freedesktop/UDisks/devices/"))) if ((!partition_slave) || (strlen(partition_slave) < sizeof("/org/freedesktop/UDisks/devices/")))
eina_stringshare_replace(&v->parent, partition_slave); eina_stringshare_replace(&v->parent, partition_slave);
@ -688,7 +688,7 @@ _e_fm_main_udisks_vol_mount_timeout(E_Volume *v)
v->guard = NULL; v->guard = NULL;
if (v->op) if (v->op)
edbus_pending_cancel(v->op); eldbus_pending_cancel(v->op);
v->op = NULL; v->op = NULL;
v->optype = E_VOLUME_OP_TYPE_NONE; v->optype = E_VOLUME_OP_TYPE_NONE;
size = _e_fm_main_udisks_format_error_msg(&buf, v, 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; v->guard = NULL;
if (v->op) if (v->op)
edbus_pending_cancel(v->op); eldbus_pending_cancel(v->op);
v->op = NULL; v->op = NULL;
v->optype = E_VOLUME_OP_TYPE_NONE; v->optype = E_VOLUME_OP_TYPE_NONE;
size = _e_fm_main_udisks_format_error_msg(&buf, v, 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; v->guard = NULL;
if (v->op) if (v->op)
edbus_pending_cancel(v->op); eldbus_pending_cancel(v->op);
v->op = NULL; v->op = NULL;
v->optype = E_VOLUME_OP_TYPE_NONE; v->optype = E_VOLUME_OP_TYPE_NONE;
size = _e_fm_main_udisks_format_error_msg(&buf, v, 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 static void
_volume_task_cb(void *data __UNUSED__, const EDBus_Message *msg __UNUSED__, _volume_task_cb(void *data __UNUSED__, const Eldbus_Message *msg __UNUSED__,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
/** /**
* if edbus_proxy_send has callback == NULL it will return a NULL * if eldbus_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 * 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 /* 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 * are not interested in the return anymore. I.e.: don't bother to cancel it
*/ */
} }
static EDBus_Pending * static Eldbus_Pending *
_volume_umount(EDBus_Proxy *proxy) _volume_umount(Eldbus_Proxy *proxy)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *array, *main_iter; Eldbus_Message_Iter *array, *main_iter;
msg = edbus_proxy_method_call_new(proxy, "FilesystemUnmount"); msg = eldbus_proxy_method_call_new(proxy, "FilesystemUnmount");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_arguments_append(main_iter, "as", &array); eldbus_message_iter_arguments_append(main_iter, "as", &array);
edbus_message_iter_container_close(main_iter, 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 * static Eldbus_Pending *
_volume_eject(EDBus_Proxy *proxy) _volume_eject(Eldbus_Proxy *proxy)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *array, *main_iter; Eldbus_Message_Iter *array, *main_iter;
msg = edbus_proxy_method_call_new(proxy, "DriveEject"); msg = eldbus_proxy_method_call_new(proxy, "DriveEject");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_arguments_append(main_iter, "as", &array); eldbus_message_iter_arguments_append(main_iter, "as", &array);
edbus_message_iter_container_close(main_iter, 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 * static Eldbus_Pending *
_volume_mount(EDBus_Proxy *proxy, const char *fstype, Eina_List *opt) _volume_mount(Eldbus_Proxy *proxy, const char *fstype, Eina_List *opt)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *array, *main_iter; Eldbus_Message_Iter *array, *main_iter;
Eina_List *l; Eina_List *l;
const char *opt_txt; const char *opt_txt;
msg = edbus_proxy_method_call_new(proxy, "FilesystemMount"); msg = eldbus_proxy_method_call_new(proxy, "FilesystemMount");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_arguments_append(main_iter, "sas", fstype, &array); eldbus_message_iter_arguments_append(main_iter, "sas", fstype, &array);
EINA_LIST_FOREACH(opt, l, opt_txt) EINA_LIST_FOREACH(opt, l, opt_txt)
edbus_message_iter_basic_append(array, 's', opt_txt); eldbus_message_iter_basic_append(array, 's', opt_txt);
edbus_message_iter_container_close(main_iter, 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 Eina_Bool static Eina_Bool
@ -907,7 +907,7 @@ _e_fm_main_udisks_volume_add(const char *path,
Eina_Bool first_time) Eina_Bool first_time)
{ {
E_Volume *v; E_Volume *v;
EDBus_Object *obj; Eldbus_Object *obj;
if (!path) return NULL; if (!path) return NULL;
if (_volume_find_by_dbus_path(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->icon = NULL;
v->first_time = first_time; v->first_time = first_time;
_e_vols = eina_list_append(_e_vols, v); _e_vols = eina_list_append(_e_vols, v);
obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path);
v->proxy = edbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); v->proxy = eldbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE);
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);
edbus_proxy_signal_handler_add(v->proxy, "Changed", eldbus_proxy_signal_handler_add(v->proxy, "Changed",
_e_fm_main_udisks_cb_prop_modified, v); _e_fm_main_udisks_cb_prop_modified, v);
v->guard = NULL; v->guard = NULL;
@ -962,9 +962,9 @@ _volume_del(E_Volume *v)
*/ */
if (v->proxy) if (v->proxy)
{ {
EDBus_Object *obj = edbus_proxy_object_get(v->proxy); Eldbus_Object *obj = eldbus_proxy_object_get(v->proxy);
edbus_proxy_unref(v->proxy); eldbus_proxy_unref(v->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
} }
_e_vols = eina_list_remove(_e_vols, v); _e_vols = eina_list_remove(_e_vols, v);
_e_fm_shared_device_volume_free(v); _e_fm_shared_device_volume_free(v);
@ -1084,11 +1084,11 @@ _e_fm_main_udisks_volume_mount(E_Volume *v)
void void
_e_fm_main_udisks_init(void) _e_fm_main_udisks_init(void)
{ {
edbus_init(); eldbus_init();
_e_fm_main_udisks_conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); _e_fm_main_udisks_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
if (!_e_fm_main_udisks_conn) return; 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); _e_fm_main_udisks_name_start, NULL);
} }
@ -1097,21 +1097,21 @@ _e_fm_main_udisks_shutdown(void)
{ {
if (_e_fm_main_udisks_proxy) if (_e_fm_main_udisks_proxy)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
obj = edbus_proxy_object_get(_e_fm_main_udisks_proxy); obj = eldbus_proxy_object_get(_e_fm_main_udisks_proxy);
edbus_proxy_unref(_e_fm_main_udisks_proxy); eldbus_proxy_unref(_e_fm_main_udisks_proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
} }
if (_e_fm_main_udisks_conn) if (_e_fm_main_udisks_conn)
edbus_connection_unref(_e_fm_main_udisks_conn); eldbus_connection_unref(_e_fm_main_udisks_conn);
edbus_shutdown(); eldbus_shutdown();
} }
E_Storage * E_Storage *
_e_fm_main_udisks_storage_add(const char *path) _e_fm_main_udisks_storage_add(const char *path)
{ {
E_Storage *s; E_Storage *s;
EDBus_Object *obj; Eldbus_Object *obj;
if (!path) return NULL; if (!path) return NULL;
if (_storage_find_by_dbus_path(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); DBG("STORAGE+=%s", path);
s->dbus_path = path; s->dbus_path = path;
_e_stores = eina_list_append(_e_stores, s); _e_stores = eina_list_append(_e_stores, s);
obj = edbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path); obj = eldbus_object_get(_e_fm_main_udisks_conn, UDISKS_BUS, path);
s->proxy = edbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE); s->proxy = eldbus_proxy_get(obj, UDISKS_DEVICE_INTERFACE);
edbus_proxy_property_get_all(s->proxy, _e_fm_main_udisks_cb_store_prop, s); eldbus_proxy_property_get_all(s->proxy, _e_fm_main_udisks_cb_store_prop, s);
return s; return s;
} }
@ -1145,9 +1145,9 @@ _e_fm_main_udisks_storage_del(const char *path)
_e_stores = eina_list_remove(_e_stores, s); _e_stores = eina_list_remove(_e_stores, s);
if (s->proxy) if (s->proxy)
{ {
EDBus_Object *obj = edbus_proxy_object_get(s->proxy); Eldbus_Object *obj = eldbus_proxy_object_get(s->proxy);
edbus_proxy_unref(s->proxy); eldbus_proxy_unref(s->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
} }
_e_fm_shared_device_storage_free(s); _e_fm_shared_device_storage_free(s);
} }

26
src/bin/e_fm_cmdline.c
View File

@ -4,16 +4,16 @@
#include "e.h" #include "e.h"
static EDBus_Connection *conn = NULL; static Eldbus_Connection *conn = NULL;
static int retval = EXIT_SUCCESS; static int retval = EXIT_SUCCESS;
static int pending = 0; static int pending = 0;
static void static void
fm_open_reply(void *data __UNUSED__, const EDBus_Message *msg, fm_open_reply(void *data __UNUSED__, const Eldbus_Message *msg,
EDBus_Pending *dbus_pending __UNUSED__) Eldbus_Pending *dbus_pending __UNUSED__)
{ {
const char *name, *txt; const char *name, *txt;
if (edbus_message_error_get(msg, &name, &txt)) if (eldbus_message_error_get(msg, &name, &txt))
{ {
retval = EXIT_FAILURE; retval = EXIT_FAILURE;
ERR("%s: %s", name, txt); ERR("%s: %s", name, txt);
@ -33,7 +33,7 @@ fm_error_quit_last(void *data __UNUSED__)
static void static void
fm_open(const char *path) fm_open(const char *path)
{ {
EDBus_Message *msg; Eldbus_Message *msg;
const char *method; const char *method;
char *p; char *p;
@ -87,7 +87,7 @@ fm_open(const char *path)
else else
method = "OpenFile"; 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",
"org.enlightenment.FileManager", "org.enlightenment.FileManager",
method); method);
@ -98,13 +98,13 @@ fm_open(const char *path)
free(p); free(p);
return; return;
} }
edbus_message_arguments_append(msg, "s", p); eldbus_message_arguments_append(msg, "s", p);
free(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"); ERR("Could not send DBus Message");
edbus_message_unref(msg); eldbus_message_unref(msg);
ecore_idler_add(fm_error_quit_last, NULL); ecore_idler_add(fm_error_quit_last, NULL);
} }
else else
@ -152,9 +152,9 @@ main(int argc, char *argv[])
ecore_init(); ecore_init();
ecore_file_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) if (!conn)
{ {
ERR("Could not DBus SESSION bus."); ERR("Could not DBus SESSION bus.");
@ -172,9 +172,9 @@ main(int argc, char *argv[])
} }
ecore_main_loop_begin(); ecore_main_loop_begin();
edbus_connection_unref(conn); eldbus_connection_unref(conn);
end: end:
edbus_shutdown(); eldbus_shutdown();
ecore_file_shutdown(); ecore_file_shutdown();
ecore_shutdown(); ecore_shutdown();
return retval; return retval;

8
src/bin/e_fm_shared_types.h.in
View File

@ -9,7 +9,7 @@
# include <Eeze_Disk.h> # include <Eeze_Disk.h>
#endif #endif
#if @DBUS_MOUNT_CONFIG@ #if @DBUS_MOUNT_CONFIG@
# include <EDBus.h> # include <Eldbus.h>
#endif #endif
# define E_DEVICE_TYPE_STORAGE 1 # define E_DEVICE_TYPE_STORAGE 1
@ -71,7 +71,7 @@ struct _E_Storage
Eina_Bool validated : 1; Eina_Bool validated : 1;
Eina_Bool trackable : 1; Eina_Bool trackable : 1;
#if @DBUS_MOUNT_CONFIG@ #if @DBUS_MOUNT_CONFIG@
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
const char *dbus_path; const char *dbus_path;
#endif #endif
#if @EEZE_MOUNT_CONFIG@ #if @EEZE_MOUNT_CONFIG@
@ -111,8 +111,8 @@ struct _E_Volume
Eina_Bool unlocked; Eina_Bool unlocked;
#if @DBUS_MOUNT_CONFIG@ #if @DBUS_MOUNT_CONFIG@
EDBus_Pending *op; Eldbus_Pending *op;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
const char *dbus_path; const char *dbus_path;
#endif #endif
#if @EEZE_MOUNT_CONFIG@ #if @EEZE_MOUNT_CONFIG@

330
src/bin/e_msgbus.c
View File

@ -1,39 +1,39 @@
#include "e.h" #include "e.h"
/* local subsystem functions */ /* local subsystem functions */
static void _e_msgbus_request_name_cb(void *data, const EDBus_Message *msg, static void _e_msgbus_request_name_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending); Eldbus_Pending *pending);
static EDBus_Message *_e_msgbus_core_restart_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_core_restart_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_core_shutdown_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_core_shutdown_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_module_load_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_module_load_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_module_unload_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_module_enable_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_module_disable_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_module_list_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_module_list_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_profile_set_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_profile_get_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_profile_get_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_profile_list_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_profile_list_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_profile_add_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_profile_add_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
static EDBus_Message *_e_msgbus_profile_delete_cb(const EDBus_Service_Interface *iface, static Eldbus_Message *_e_msgbus_profile_delete_cb(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg); const Eldbus_Message *msg);
#define E_MSGBUS_WIN_ACTION_CB_PROTO(NAME) \ #define E_MSGBUS_WIN_ACTION_CB_PROTO(NAME) \
static EDBus_Message * _e_msgbus_window_##NAME##_cb(const EDBus_Service_Interface * iface, \ static Eldbus_Message * _e_msgbus_window_##NAME##_cb(const Eldbus_Service_Interface * iface, \
const EDBus_Message * msg) const Eldbus_Message * msg)
E_MSGBUS_WIN_ACTION_CB_PROTO(list); E_MSGBUS_WIN_ACTION_CB_PROTO(list);
E_MSGBUS_WIN_ACTION_CB_PROTO(close); E_MSGBUS_WIN_ACTION_CB_PROTO(close);
@ -47,64 +47,64 @@ E_MSGBUS_WIN_ACTION_CB_PROTO(unmaximize);
/* local subsystem globals */ /* local subsystem globals */
static E_Msgbus_Data *_e_msgbus_data = NULL; 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 }, { "Restart", NULL, NULL, _e_msgbus_core_restart_cb },
{ "Shutdown", NULL, NULL, _e_msgbus_core_shutdown_cb }, { "Shutdown", NULL, NULL, _e_msgbus_core_shutdown_cb },
{ } { }
}; };
static const EDBus_Method module_methods[] = { static const Eldbus_Method module_methods[] = {
{ "Load", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_load_cb }, { "Load", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_load_cb },
{ "Unload", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_unload_cb }, { "Unload", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_unload_cb },
{ "Enable", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_enable_cb }, { "Enable", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_enable_cb },
{ "Disable", EDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_disable_cb }, { "Disable", ELDBUS_ARGS({"s", "module"}), NULL, _e_msgbus_module_disable_cb },
{ "List", NULL, EDBUS_ARGS({"a(si)", "modules"}), { "List", NULL, ELDBUS_ARGS({"a(si)", "modules"}),
_e_msgbus_module_list_cb }, _e_msgbus_module_list_cb },
{ } { }
}; };
static const EDBus_Method profile_methods[] = { static const Eldbus_Method profile_methods[] = {
{ "Set", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_set_cb }, { "Set", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_set_cb },
{ "Get", NULL, EDBUS_ARGS({"s", "profile"}), _e_msgbus_profile_get_cb }, { "Get", NULL, ELDBUS_ARGS({"s", "profile"}), _e_msgbus_profile_get_cb },
{ "List", NULL, EDBUS_ARGS({"as", "array_profiles"}), { "List", NULL, ELDBUS_ARGS({"as", "array_profiles"}),
_e_msgbus_profile_list_cb }, _e_msgbus_profile_list_cb },
{ "Add", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_add_cb }, { "Add", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_add_cb },
{ "Delete", EDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_delete_cb }, { "Delete", ELDBUS_ARGS({"s", "profile"}), NULL, _e_msgbus_profile_delete_cb },
{ } { }
}; };
static const EDBus_Method window_methods[] = { static const Eldbus_Method window_methods[] = {
{ "List", NULL, EDBUS_ARGS({"a(si)", "array_of_window"}), { "List", NULL, ELDBUS_ARGS({"a(si)", "array_of_window"}),
_e_msgbus_window_list_cb }, _e_msgbus_window_list_cb },
{ "Close", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_close_cb }, { "Close", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_close_cb },
{ "Kill", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_kill_cb }, { "Kill", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_kill_cb },
{ "Focus", EDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_focus_cb }, { "Focus", ELDBUS_ARGS({"i", "window_id"}), NULL, _e_msgbus_window_focus_cb },
{ "Iconify", EDBUS_ARGS({"i", "window_id"}), NULL, { "Iconify", ELDBUS_ARGS({"i", "window_id"}), NULL,
_e_msgbus_window_iconify_cb }, _e_msgbus_window_iconify_cb },
{ "Uniconify", EDBUS_ARGS({"i", "window_id"}), NULL, { "Uniconify", ELDBUS_ARGS({"i", "window_id"}), NULL,
_e_msgbus_window_uniconify_cb }, _e_msgbus_window_uniconify_cb },
{ "Maximize", EDBUS_ARGS({"i", "window_id"}), NULL, { "Maximize", ELDBUS_ARGS({"i", "window_id"}), NULL,
_e_msgbus_window_maximize_cb }, _e_msgbus_window_maximize_cb },
{ "Unmaximize", EDBUS_ARGS({"i", "window_id"}), NULL, { "Unmaximize", ELDBUS_ARGS({"i", "window_id"}), NULL,
_e_msgbus_window_unmaximize_cb }, _e_msgbus_window_unmaximize_cb },
{ } { }
}; };
#define PATH "/org/enlightenment/wm/RemoteObject" #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 "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 "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 "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 "org.enlightenment.wm.Window", window_methods
}; };
@ -114,21 +114,21 @@ e_msgbus_init(void)
{ {
_e_msgbus_data = E_NEW(E_Msgbus_Data, 1); _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) if (!_e_msgbus_data->conn)
{ {
WRN("Cannot get EDBUS_CONNECTION_TYPE_SESSION"); WRN("Cannot get ELDBUS_CONNECTION_TYPE_SESSION");
return 0; 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); PATH, &core_desc);
edbus_service_interface_register(_e_msgbus_data->conn, PATH, &module_desc); eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &module_desc);
edbus_service_interface_register(_e_msgbus_data->conn, PATH, &profile_desc); eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &profile_desc);
edbus_service_interface_register(_e_msgbus_data->conn, PATH, &window_desc); eldbus_service_interface_register(_e_msgbus_data->conn, PATH, &window_desc);
edbus_name_request(_e_msgbus_data->conn, "org.enlightenment.wm.service", eldbus_name_request(_e_msgbus_data->conn, "org.enlightenment.wm.service",
0, _e_msgbus_request_name_cb, NULL); 0, _e_msgbus_request_name_cb, NULL);
return 1; return 1;
} }
@ -137,76 +137,76 @@ EINTERN int
e_msgbus_shutdown(void) e_msgbus_shutdown(void)
{ {
if (_e_msgbus_data->iface) 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) 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); "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_FREE(_e_msgbus_data);
_e_msgbus_data = NULL; _e_msgbus_data = NULL;
return 1; return 1;
} }
EAPI EDBus_Service_Interface * EAPI Eldbus_Service_Interface *
e_msgbus_interface_attach(const EDBus_Service_Interface_Desc *desc) e_msgbus_interface_attach(const Eldbus_Service_Interface_Desc *desc)
{ {
if (!_e_msgbus_data->iface) if (!_e_msgbus_data->iface)
return NULL; 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 static void
_e_msgbus_request_name_cb(void *data __UNUSED__, const EDBus_Message *msg, _e_msgbus_request_name_cb(void *data __UNUSED__, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
unsigned int flag; 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"); ERR("Could not request bus name");
return; 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"); ERR("Could not get arguments on on_name_request");
return; return;
} }
if (!(flag & EDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER)) if (!(flag & ELDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER))
ERR("Name already in use\n"); ERR("Name already in use\n");
} }
/* Core Handlers */ /* Core Handlers */
static EDBus_Message * static Eldbus_Message *
_e_msgbus_core_restart_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_core_restart_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
e_sys_action_do(E_SYS_RESTART, NULL); 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 * static Eldbus_Message *
_e_msgbus_core_shutdown_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_core_shutdown_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
e_sys_action_do(E_SYS_EXIT, NULL); e_sys_action_do(E_SYS_EXIT, NULL);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
/* Modules Handlers */ /* Modules Handlers */
static EDBus_Message * static Eldbus_Message *
_e_msgbus_module_load_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_module_load_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *module; 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; return reply;
if (!e_module_find(module)) if (!e_module_find(module))
@ -218,15 +218,15 @@ _e_msgbus_module_load_cb(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_module_unload_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *module; char *module;
E_Module *m; 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; return reply;
if ((m = e_module_find(module))) if ((m = e_module_find(module)))
@ -239,15 +239,15 @@ _e_msgbus_module_unload_cb(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_module_enable_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *module; char *module;
E_Module *m; 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; return reply;
if ((m = e_module_find(module))) if ((m = e_module_find(module)))
@ -259,15 +259,15 @@ _e_msgbus_module_enable_cb(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_module_disable_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *module; char *module;
E_Module *m; 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; return reply;
if ((m = e_module_find(module))) if ((m = e_module_find(module)))
@ -279,50 +279,50 @@ _e_msgbus_module_disable_cb(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_module_list_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_module_list_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
Eina_List *l; Eina_List *l;
E_Module *mod; E_Module *mod;
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
EDBus_Message_Iter *main_iter, *array; Eldbus_Message_Iter *main_iter, *array;
EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL); 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); 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_SAFETY_ON_NULL_RETURN_VAL(array, reply);
EINA_LIST_FOREACH(e_module_list(), l, mod) EINA_LIST_FOREACH(e_module_list(), l, mod)
{ {
EDBus_Message_Iter *s; Eldbus_Message_Iter *s;
const char *name; const char *name;
int enabled; int enabled;
name = mod->name; name = mod->name;
enabled = mod->enabled; enabled = mod->enabled;
edbus_message_iter_arguments_append(array, "(si)", &s); eldbus_message_iter_arguments_append(array, "(si)", &s);
if (!s) continue; if (!s) continue;
edbus_message_iter_arguments_append(s, "si", name, enabled); eldbus_message_iter_arguments_append(s, "si", name, enabled);
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; return reply;
} }
/* Profile Handlers */ /* Profile Handlers */
static EDBus_Message * static Eldbus_Message *
_e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_profile_set_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *profile; 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; return reply;
e_config_save_flush(); e_config_save_flush();
@ -334,129 +334,129 @@ _e_msgbus_profile_set_cb(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_profile_get_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_profile_get_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) 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; const char *profile;
EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL);
profile = e_config_profile_get(); profile = e_config_profile_get();
edbus_message_arguments_append(reply, "s", profile); eldbus_message_arguments_append(reply, "s", profile);
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_profile_list_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_profile_list_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
Eina_List *l; Eina_List *l;
char *name; char *name;
EDBus_Message *reply; Eldbus_Message *reply;
EDBus_Message_Iter *array, *main_iter; 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); 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); 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); EINA_SAFETY_ON_FALSE_RETURN_VAL(array, reply);
l = e_config_profile_list(); l = e_config_profile_list();
EINA_LIST_FREE(l, name) EINA_LIST_FREE(l, name)
{ {
edbus_message_iter_basic_append(array, 's', name); eldbus_message_iter_basic_append(array, 's', name);
free(name); free(name);
} }
edbus_message_iter_container_close(main_iter, array); eldbus_message_iter_container_close(main_iter, array);
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_profile_add_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_profile_add_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *profile; 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; return reply;
e_config_profile_add(profile); e_config_profile_add(profile);
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_e_msgbus_profile_delete_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_profile_delete_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
char *profile; char *profile;
if (!edbus_message_arguments_get(msg, "s", &profile)) if (!eldbus_message_arguments_get(msg, "s", &profile))
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
if (!strcmp(e_config_profile_get(), profile)) if (!strcmp(e_config_profile_get(), profile))
return edbus_message_error_new(msg, return eldbus_message_error_new(msg,
"org.enlightenment.DBus.InvalidArgument", "org.enlightenment.DBus.InvalidArgument",
"Can't delete active profile"); "Can't delete active profile");
e_config_profile_del(profile); e_config_profile_del(profile);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
/* Window handlers */ /* Window handlers */
static EDBus_Message * static Eldbus_Message *
_e_msgbus_window_list_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_msgbus_window_list_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
Eina_List *l; Eina_List *l;
E_Border *bd; E_Border *bd;
EDBus_Message *reply; Eldbus_Message *reply;
EDBus_Message_Iter *main_iter, *array; 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); 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); 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_SAFETY_ON_FALSE_RETURN_VAL(array, reply);
EINA_LIST_FOREACH(e_border_client_list(), l, bd) 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; 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); 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; return reply;
} }
#define E_MSGBUS_WIN_ACTION_CB_BEGIN(NAME) \ #define E_MSGBUS_WIN_ACTION_CB_BEGIN(NAME) \
static EDBus_Message * \ static Eldbus_Message * \
_e_msgbus_window_##NAME##_cb(const EDBus_Service_Interface * iface __UNUSED__, \ _e_msgbus_window_##NAME##_cb(const Eldbus_Service_Interface * iface __UNUSED__, \
const EDBus_Message * msg) \ const Eldbus_Message * msg) \
{ \ { \
E_Border *bd; \ E_Border *bd; \
int xwin; \ int xwin; \
\ \
if (!edbus_message_arguments_get(msg, "i", &xwin)) \ if (!eldbus_message_arguments_get(msg, "i", &xwin)) \
return edbus_message_method_return_new(msg); \ return eldbus_message_method_return_new(msg); \
bd = e_border_find_by_client_window(xwin); \ bd = e_border_find_by_client_window(xwin); \
if (bd) \ if (bd) \
{ {
#define E_MSGBUS_WIN_ACTION_CB_END \ #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) E_MSGBUS_WIN_ACTION_CB_BEGIN(close)

8
src/bin/e_msgbus.h
View File

@ -6,17 +6,17 @@ typedef struct _E_Msgbus_Data E_Msgbus_Data;
#ifndef E_MSGBUS_H #ifndef E_MSGBUS_H
#define 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 struct _E_Msgbus_Data
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
}; };
EINTERN int e_msgbus_init(void); EINTERN int e_msgbus_init(void);
EINTERN int e_msgbus_shutdown(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
#endif #endif

200
src/bin/e_notification.c
View File

@ -2,8 +2,8 @@
typedef struct _Notification_Data typedef struct _Notification_Data
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
E_Notification_Notify_Cb notify_cb; E_Notification_Notify_Cb notify_cb;
E_Notification_Close_Cb close_cb; E_Notification_Close_Cb close_cb;
void *data; void *data;
@ -13,22 +13,22 @@ typedef struct _Notification_Data
static Notification_Data *n_data = NULL; static Notification_Data *n_data = NULL;
static void 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; E_Notification_Notify *n = data;
if (!strcmp(key, "image-data") || !strcmp(key, "image_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; int w, h, r, bits, channels;
Eina_Bool alpha; Eina_Bool alpha;
unsigned char *raw_data; unsigned char *raw_data;
if (!edbus_message_iter_arguments_get(var, "(iiibiiay)", &st)) if (!eldbus_message_iter_arguments_get(var, "(iiibiiay)", &st))
return; 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, &alpha, &bits, &channels,
&data_iter)) &data_iter))
return; 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.data_size);
n->icon.raw.width = w; n->icon.raw.width = w;
n->icon.raw.height = h; 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")) else if (!strcmp(key, "urgency"))
{ {
unsigned char urgency; unsigned char urgency;
edbus_message_iter_arguments_get(var, "y", &urgency); eldbus_message_iter_arguments_get(var, "y", &urgency);
if (urgency < 3) if (urgency < 3)
n->urgency = urgency; n->urgency = urgency;
} }
else if (!strcmp(key, "image-path") || !strcmp(key, "image_path")) 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); n->icon.icon_path = eina_stringshare_add(n->icon.icon_path);
} }
} }
static EDBus_Message * static Eldbus_Message *
notify_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) notify_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{ {
E_Notification_Notify *n; E_Notification_Notify *n;
EDBus_Message_Iter *actions_iter, *hints_iter; Eldbus_Message_Iter *actions_iter, *hints_iter;
EDBus_Message *reply; Eldbus_Message *reply;
if (!n_data->notify_cb) if (!n_data->notify_cb)
return NULL; 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)); n = calloc(1, sizeof(E_Notification_Notify));
EINA_SAFETY_ON_NULL_RETURN_VAL(n, NULL); 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->replaces_id, &n->icon.icon, &n->sumary,
&n->body, &actions_iter, &hints_iter, &n->body, &actions_iter, &hints_iter,
&n->timeout)) &n->timeout))
@ -76,66 +76,66 @@ notify_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message
free(n); free(n);
return NULL; 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->app_name = eina_stringshare_add(n->app_name);
n->icon.icon = eina_stringshare_add(n->icon.icon); n->icon.icon = eina_stringshare_add(n->icon.icon);
n->sumary = eina_stringshare_add(n->sumary); n->sumary = eina_stringshare_add(n->sumary);
n->body = eina_stringshare_add(n->body); n->body = eina_stringshare_add(n->body);
n->id = n_data->notify_cb(n_data->data, n); n->id = n_data->notify_cb(n_data->data, n);
reply = edbus_message_method_return_new(msg); reply = eldbus_message_method_return_new(msg);
edbus_message_arguments_append(reply, "u", n->id); eldbus_message_arguments_append(reply, "u", n->id);
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
close_notification_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) close_notification_cb(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{ {
unsigned id; unsigned id;
if (!edbus_message_arguments_get(msg, "u", &id)) if (!eldbus_message_arguments_get(msg, "u", &id))
return NULL; return NULL;
if (n_data->close_cb) if (n_data->close_cb)
n_data->close_cb(n_data->data, id); 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 * static Eldbus_Message *
capabilities_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) 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; int i;
EDBus_Message_Iter *main_iter, *array; Eldbus_Message_Iter *main_iter, *array;
main_iter = edbus_message_iter_get(reply); main_iter = eldbus_message_iter_get(reply);
edbus_message_iter_arguments_append(main_iter, "as", &array); eldbus_message_iter_arguments_append(main_iter, "as", &array);
for (i = 0; n_data->server_info->capabilities[i]; i++) 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]); n_data->server_info->capabilities[i]);
edbus_message_iter_container_close(main_iter, array); eldbus_message_iter_container_close(main_iter, array);
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
server_info_cb(const EDBus_Service_Interface *iface EINA_UNUSED, const EDBus_Message *msg) server_info_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);
edbus_message_arguments_append(reply, "ssss", n_data->server_info->name, eldbus_message_arguments_append(reply, "ssss", n_data->server_info->name,
n_data->server_info->vendor, n_data->server_info->vendor,
n_data->server_info->version, n_data->server_info->version,
n_data->server_info->spec_version); n_data->server_info->spec_version);
return reply; return reply;
} }
static const EDBus_Method methods[] = { static const Eldbus_Method methods[] = {
{ "Notify", { "Notify",
EDBUS_ARGS({"s", "app_name"}, {"u", "replaces_id"}, {"s", "app_icon"}, {"s", "summary"}, {"s", "body"}, {"as", "actions"}, {"a{sv}", "hints"}, {"i", "expire_timeout"}), ELDBUS_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 }, ELDBUS_ARGS({"u", "id"}), notify_cb },
{ "CloseNotification", EDBUS_ARGS({"u", "id"}), NULL, close_notification_cb }, { "CloseNotification", ELDBUS_ARGS({"u", "id"}), NULL, close_notification_cb },
{ "GetCapabilities", NULL, EDBUS_ARGS({"as", "capabilities"}), { "GetCapabilities", NULL, ELDBUS_ARGS({"as", "capabilities"}),
capabilities_cb }, capabilities_cb },
{ "GetServerInformation", NULL, { "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 }, server_info_cb },
{ } { }
}; };
@ -146,11 +146,11 @@ enum
SIGNAL_ACTION_INVOKED, SIGNAL_ACTION_INVOKED,
}; };
static const EDBus_Signal signals[] = { static const Eldbus_Signal signals[] = {
[SIGNAL_NOTIFICATION_CLOSED] = [SIGNAL_NOTIFICATION_CLOSED] =
{ "NotificationClosed", EDBUS_ARGS({"u", "id"}, {"u", "reason"}) }, { "NotificationClosed", ELDBUS_ARGS({"u", "id"}, {"u", "reason"}) },
[SIGNAL_ACTION_INVOKED] = [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 BUS "org.freedesktop.Notifications"
#define INTERFACE "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 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)); n_data = calloc(1, sizeof(Notification_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(n_data, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(n_data, EINA_FALSE);
edbus_init(); eldbus_init();
n_data->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); n_data->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
n_data->iface = edbus_service_interface_register(n_data->conn, PATH, &desc); n_data->iface = eldbus_service_interface_register(n_data->conn, PATH, &desc);
n_data->notify_cb = n_cb; n_data->notify_cb = n_cb;
n_data->close_cb = close_cb; n_data->close_cb = close_cb;
n_data->data = (void *)data; n_data->data = (void *)data;
n_data->server_info = server_info; n_data->server_info = server_info;
edbus_name_request(n_data->conn, BUS, eldbus_name_request(n_data->conn, BUS,
EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL);
return EINA_TRUE; return EINA_TRUE;
} }
@ -188,9 +188,9 @@ EAPI void
e_notification_server_unregister(void) e_notification_server_unregister(void)
{ {
EINA_SAFETY_ON_NULL_RETURN(n_data); EINA_SAFETY_ON_NULL_RETURN(n_data);
edbus_service_interface_unregister(n_data->iface); eldbus_service_interface_unregister(n_data->iface);
edbus_connection_unref(n_data->conn); eldbus_connection_unref(n_data->conn);
edbus_shutdown(); eldbus_shutdown();
free(n_data); free(n_data);
n_data = NULL; 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(n_data);
EINA_SAFETY_ON_NULL_RETURN(notify); EINA_SAFETY_ON_NULL_RETURN(notify);
EINA_SAFETY_ON_FALSE_RETURN(reason <= E_NOTIFICATION_NOTIFY_CLOSED_REASON_UNDEFINED); 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); notify->id, reason);
} }
@ -277,40 +277,40 @@ error:
/* client API */ /* client API */
static void 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; unsigned id = 0;
E_Notification_Client_Send_Cb cb = edbus_pending_data_del(pending, "cb"); E_Notification_Client_Send_Cb cb = eldbus_pending_data_del(pending, "cb");
EDBus_Connection *conn = edbus_pending_data_del(pending, "conn"); Eldbus_Connection *conn = eldbus_pending_data_del(pending, "conn");
if (edbus_message_error_get(msg, NULL, NULL)) if (eldbus_message_error_get(msg, NULL, NULL))
goto end; goto end;
if (!edbus_message_arguments_get(msg, "u", &id)) if (!eldbus_message_arguments_get(msg, "u", &id))
goto end; goto end;
end: end:
cb(data, id); cb(data, id);
edbus_connection_unref(conn); eldbus_connection_unref(conn);
edbus_shutdown(); eldbus_shutdown();
} }
static Eina_Bool static Eina_Bool
notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Client_Send_Cb cb, const void *data) notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Client_Send_Cb cb, const void *data)
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Message_Iter *main_iter, *actions, *hints; Eldbus_Message_Iter *main_iter, *actions, *hints;
EDBus_Message_Iter *entry, *var; Eldbus_Message_Iter *entry, *var;
EDBus_Pending *p; Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(notify, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(notify, EINA_FALSE);
edbus_init(); eldbus_init();
conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, EINA_FALSE); 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); EINA_SAFETY_ON_NULL_RETURN_VAL(msg, EINA_FALSE);
//build message //build message
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
if (!edbus_message_iter_arguments_append(main_iter, "susssas", if (!eldbus_message_iter_arguments_append(main_iter, "susssas",
notify->app_name ? : "", notify->app_name ? : "",
notify->replaces_id, notify->replaces_id,
notify->icon.icon ? : "", notify->icon.icon ? : "",
@ -318,19 +318,19 @@ notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Clie
notify->body ? : "", notify->body ? : "",
&actions)) &actions))
goto error; goto error;
edbus_message_iter_container_close(main_iter, actions); eldbus_message_iter_container_close(main_iter, actions);
if (!edbus_message_iter_arguments_append(main_iter, "a{sv}", &hints)) if (!eldbus_message_iter_arguments_append(main_iter, "a{sv}", &hints))
goto error; goto error;
if (notify->icon.raw.data) if (notify->icon.raw.data)
{ {
EDBus_Message_Iter *st, *data_iter; Eldbus_Message_Iter *st, *data_iter;
int i; int i;
edbus_message_iter_arguments_append(hints, "{sv}", &entry); eldbus_message_iter_arguments_append(hints, "{sv}", &entry);
edbus_message_iter_arguments_append(entry, "s", "image-data"); eldbus_message_iter_arguments_append(entry, "s", "image-data");
var = edbus_message_iter_container_new(entry, 'v', "(iiibiiay)"); var = eldbus_message_iter_container_new(entry, 'v', "(iiibiiay)");
edbus_message_iter_arguments_append(var, "(iiibiiay)", &st); eldbus_message_iter_arguments_append(var, "(iiibiiay)", &st);
edbus_message_iter_arguments_append(st, "iiibiiay", eldbus_message_iter_arguments_append(st, "iiibiiay",
notify->icon.raw.width, notify->icon.raw.width,
notify->icon.raw.height, notify->icon.raw.height,
notify->icon.raw.rowstride, notify->icon.raw.rowstride,
@ -339,42 +339,42 @@ notification_client_dbus_send(E_Notification_Notify *notify, E_Notification_Clie
notify->icon.raw.channels, notify->icon.raw.channels,
&data_iter); &data_iter);
for (i = 0; i < notify->icon.raw.data_size; i++) for (i = 0; i < notify->icon.raw.data_size; i++)
edbus_message_iter_basic_append(data_iter, 'y', notify->icon.raw.data[i]); eldbus_message_iter_basic_append(data_iter, 'y', notify->icon.raw.data[i]);
edbus_message_iter_container_close(st, data_iter); eldbus_message_iter_container_close(st, data_iter);
edbus_message_iter_container_close(var, st); eldbus_message_iter_container_close(var, st);
edbus_message_iter_container_close(entry, var); eldbus_message_iter_container_close(entry, var);
edbus_message_iter_container_close(hints, entry); eldbus_message_iter_container_close(hints, entry);
} }
if (notify->icon.icon_path) if (notify->icon.icon_path)
{ {
edbus_message_iter_arguments_append(hints, "{sv}", &entry); eldbus_message_iter_arguments_append(hints, "{sv}", &entry);
edbus_message_iter_arguments_append(entry, "s", "image-path"); eldbus_message_iter_arguments_append(entry, "s", "image-path");
var = edbus_message_iter_container_new(entry, 'v', "s"); var = eldbus_message_iter_container_new(entry, 'v', "s");
edbus_message_iter_arguments_append(var, "s", notify->icon.icon_path); eldbus_message_iter_arguments_append(var, "s", notify->icon.icon_path);
edbus_message_iter_container_close(entry, var); eldbus_message_iter_container_close(entry, var);
edbus_message_iter_container_close(hints, entry); eldbus_message_iter_container_close(hints, entry);
} }
edbus_message_iter_arguments_append(hints, "{sv}", &entry); eldbus_message_iter_arguments_append(hints, "{sv}", &entry);
edbus_message_iter_arguments_append(entry, "s", "urgency"); eldbus_message_iter_arguments_append(entry, "s", "urgency");
var = edbus_message_iter_container_new(entry, 'v', "y"); var = eldbus_message_iter_container_new(entry, 'v', "y");
edbus_message_iter_arguments_append(var, "y", notify->urgency); eldbus_message_iter_arguments_append(var, "y", notify->urgency);
edbus_message_iter_container_close(entry, var); eldbus_message_iter_container_close(entry, var);
edbus_message_iter_container_close(hints, entry); 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); EINA_SAFETY_ON_NULL_GOTO(p, error);
edbus_pending_data_set(p, "cb", cb); eldbus_pending_data_set(p, "cb", cb);
edbus_pending_data_set(p, "conn", conn); eldbus_pending_data_set(p, "conn", conn);
return EINA_TRUE; return EINA_TRUE;
error: error:
edbus_message_unref(msg); eldbus_message_unref(msg);
return EINA_FALSE; return EINA_FALSE;
} }

2
src/bin/e_notification.h
View File

@ -1,7 +1,7 @@
#ifndef _E_NOTIFICATION_H #ifndef _E_NOTIFICATION_H
#define _E_NOTIFICATION_H #define _E_NOTIFICATION_H
#include <EDBus.h> #include <Eldbus.h>
#include <Eina.h> #include <Eina.h>
typedef enum _E_Notification_Notify_Urgency typedef enum _E_Notification_Notify_Urgency

10
src/modules/Makefile_music_control.am
View File

@ -14,8 +14,8 @@ music_control_module_la_SOURCES = music-control/e_mod_main.h \
music-control/e_mod_main.c \ music-control/e_mod_main.c \
music-control/private.h \ music-control/private.h \
music-control/ui.c \ music-control/ui.c \
music-control/gen/edbus_utils.h \ music-control/gen/eldbus_utils.h \
music-control/gen/edbus_media_player2_player.c \ music-control/gen/eldbus_media_player2_player.c \
music-control/gen/edbus_media_player2_player.h \ music-control/gen/eldbus_media_player2_player.h \
music-control/gen/edbus_mpris_media_player2.c \ music-control/gen/eldbus_mpris_media_player2.c \
music-control/gen/edbus_mpris_media_player2.h music-control/gen/eldbus_mpris_media_player2.h

4
src/modules/appmenu/e_mod_appmenu_private.h
View File

@ -8,8 +8,8 @@ typedef struct _E_AppMenu_Window E_AppMenu_Window;
typedef struct _E_AppMenu_Context typedef struct _E_AppMenu_Context
{ {
Eina_List *instances; Eina_List *instances;
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
Eina_List *windows; Eina_List *windows;
unsigned window_with_focus; unsigned window_with_focus;
E_AppMenu_Window *window; E_AppMenu_Window *window;

106
src/modules/appmenu/e_mod_dbus_registrar_server.c
View File

@ -16,7 +16,7 @@ void
appmenu_application_monitor(void *data, const char *bus EINA_UNUSED, const char *old __UNUSED__, const char *new __UNUSED__) appmenu_application_monitor(void *data, const char *bus EINA_UNUSED, const char *old __UNUSED__, const char *new __UNUSED__)
{ {
E_AppMenu_Window *window = data; 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); window->window_id);
appmenu_window_free(window); 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 //TODO
} }
static EDBus_Message * static Eldbus_Message *
_on_register_window(const EDBus_Service_Interface *iface, const EDBus_Message *msg) _on_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
{ {
EDBus_Connection *conn = edbus_service_connection_get(iface); Eldbus_Connection *conn = eldbus_service_connection_get(iface);
E_AppMenu_Context *ctxt = edbus_service_object_data_get(iface, "ctxt"); E_AppMenu_Context *ctxt = eldbus_service_object_data_get(iface, "ctxt");
unsigned window_id; unsigned window_id;
const char *path, *bus_id; const char *path, *bus_id;
E_AppMenu_Window *window; 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"); ERR("Error reading message");
return NULL; 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); 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->window_id = window_id;
window->dbus_menu = e_dbusmenu_load(conn, bus_id, path, window); 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->bus_id = eina_stringshare_add(bus_id);
window->path = eina_stringshare_add(path); 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); window, EINA_FALSE);
ctxt->windows = eina_list_append(ctxt->windows, window); ctxt->windows = eina_list_append(ctxt->windows, window);
window->ctxt = ctxt; 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); bus_id, path);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static E_AppMenu_Window * static E_AppMenu_Window *
@ -89,14 +89,14 @@ window_find(E_AppMenu_Context *ctxt, unsigned window_id)
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_on_unregister_window(const EDBus_Service_Interface *iface, const EDBus_Message *msg) _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; E_AppMenu_Window *w;
unsigned window_id; 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."); ERR("Error reading message.");
return NULL; return NULL;
@ -105,19 +105,19 @@ _on_unregister_window(const EDBus_Service_Interface *iface, const EDBus_Message
w = window_find(ctxt, window_id); w = window_find(ctxt, window_id);
if (w) if (w)
appmenu_window_free(w); appmenu_window_free(w);
edbus_service_signal_emit(iface, SIGNAL_WINDOW_UNREGISTERED, window_id); eldbus_service_signal_emit(iface, SIGNAL_WINDOW_UNREGISTERED, window_id);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static EDBus_Message * static Eldbus_Message *
_on_getmenu(const EDBus_Service_Interface *iface, const EDBus_Message *msg) _on_getmenu(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
{ {
unsigned window_id; unsigned window_id;
Eina_List *l; Eina_List *l;
E_AppMenu_Window *w; 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"); ERR("Error reading message");
return NULL; return NULL;
@ -126,80 +126,80 @@ _on_getmenu(const EDBus_Service_Interface *iface, const EDBus_Message *msg)
{ {
if (w->window_id == window_id) if (w->window_id == window_id)
{ {
EDBus_Message *reply; Eldbus_Message *reply;
reply = edbus_message_method_return_new(msg); reply = eldbus_message_method_return_new(msg);
edbus_message_arguments_append(reply, "so", w->bus_id, w->path); eldbus_message_arguments_append(reply, "so", w->bus_id, w->path);
return reply; 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 * static Eldbus_Message *
_on_getmenus(const EDBus_Service_Interface *iface, const EDBus_Message *msg) _on_getmenus(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
{ {
Eina_List *l; Eina_List *l;
E_AppMenu_Window *w; 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");
EDBus_Message *reply; Eldbus_Message *reply;
EDBus_Message_Iter *array, *main_iter; Eldbus_Message_Iter *array, *main_iter;
reply = edbus_message_method_return_new(msg); reply = eldbus_message_method_return_new(msg);
main_iter = edbus_message_iter_get(reply); main_iter = eldbus_message_iter_get(reply);
edbus_message_iter_arguments_append(main_iter, "a(uso)", &array); eldbus_message_iter_arguments_append(main_iter, "a(uso)", &array);
EINA_LIST_FOREACH(ctxt->windows, l, w) EINA_LIST_FOREACH(ctxt->windows, l, w)
{ {
EDBus_Message_Iter *entry; Eldbus_Message_Iter *entry;
edbus_message_iter_arguments_append(array, "(uso)", &entry); eldbus_message_iter_arguments_append(array, "(uso)", &entry);
edbus_message_iter_arguments_append(entry, "uso", w->window_id, eldbus_message_iter_arguments_append(entry, "uso", w->window_id,
w->bus_id, w->path); 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; return reply;
} }
static const EDBus_Method registrar_methods[] = { static const Eldbus_Method registrar_methods[] = {
{ "RegisterWindow", EDBUS_ARGS({"u", "windowId"},{"o", "menuObjectPath"}), { "RegisterWindow", ELDBUS_ARGS({"u", "windowId"},{"o", "menuObjectPath"}),
NULL, _on_register_window }, NULL, _on_register_window },
{ "UnregisterWindow", EDBUS_ARGS({"u", "windowId"}), { "UnregisterWindow", ELDBUS_ARGS({"u", "windowId"}),
NULL, _on_unregister_window }, NULL, _on_unregister_window },
{ "GetMenuForWindow", EDBUS_ARGS({"u", "windowId"}), { "GetMenuForWindow", ELDBUS_ARGS({"u", "windowId"}),
EDBUS_ARGS({"s", "bus_id"},{"o", "menu_path"}), _on_getmenu }, ELDBUS_ARGS({"s", "bus_id"},{"o", "menu_path"}), _on_getmenu },
{ "GetMenus", NULL, EDBUS_ARGS({"a(uso)", "array_of_menu"}), _on_getmenus }, { "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] = [SIGNAL_WINDOW_REGISTERED] =
{ "WindowRegistered", { "WindowRegistered",
EDBUS_ARGS({"u", "windowId"}, {"s", "bus_id"}, {"o", "menu_path"}) }, ELDBUS_ARGS({"u", "windowId"}, {"s", "bus_id"}, {"o", "menu_path"}) },
[SIGNAL_WINDOW_UNREGISTERED] = [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 REGISTRAR_IFACE, registrar_methods, registrar_signals
}; };
void void
appmenu_dbus_registrar_server_init(E_AppMenu_Context *ctx) 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, REGISTRAR_PATH,
&registrar_iface); &registrar_iface);
edbus_service_object_data_set(ctx->iface, "ctxt", ctx); eldbus_service_object_data_set(ctx->iface, "ctxt", ctx);
edbus_name_request(ctx->conn, REGISTRAR_BUS, eldbus_name_request(ctx->conn, REGISTRAR_BUS,
EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL);
} }
void void
appmenu_dbus_registrar_server_shutdown(E_AppMenu_Context *ctx) appmenu_dbus_registrar_server_shutdown(E_AppMenu_Context *ctx)
{ {
edbus_service_interface_unregister(ctx->iface); eldbus_service_interface_unregister(ctx->iface);
edbus_name_release(ctx->conn, REGISTRAR_BUS, NULL, NULL); eldbus_name_release(ctx->conn, REGISTRAR_BUS, NULL, NULL);
ctx->iface = NULL; ctx->iface = NULL;
} }

10
src/modules/appmenu/e_mod_main.c
View File

@ -165,8 +165,8 @@ e_modapi_init(E_Module *m)
appmenu_module = m; appmenu_module = m;
edbus_init(); eldbus_init();
ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
event = ecore_event_handler_add(E_EVENT_BORDER_FOCUS_IN, cb_focus_in, ctxt); event = ecore_event_handler_add(E_EVENT_BORDER_FOCUS_IN, cb_focus_in, ctxt);
ctxt->events[0] = event; ctxt->events[0] = event;
@ -199,8 +199,8 @@ e_modapi_shutdown(E_Module *m)
appmenu_window_free(w); appmenu_window_free(w);
appmenu_dbus_registrar_server_shutdown(ctxt); appmenu_dbus_registrar_server_shutdown(ctxt);
edbus_connection_unref(ctxt->conn); eldbus_connection_unref(ctxt->conn);
edbus_shutdown(); eldbus_shutdown();
free(ctxt); free(ctxt);
return 1; return 1;
} }
@ -210,7 +210,7 @@ appmenu_window_free(E_AppMenu_Window *window)
{ {
window->ctxt->windows = eina_list_remove(window->ctxt->windows, window); window->ctxt->windows = eina_list_remove(window->ctxt->windows, window);
e_dbusmenu_unload(window->dbus_menu); 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); appmenu_application_monitor, window);
eina_stringshare_del(window->bus_id); eina_stringshare_del(window->bus_id);
eina_stringshare_del(window->path); eina_stringshare_del(window->path);

6
src/modules/battery/e_mod_main.h
View File

@ -4,7 +4,7 @@
#ifdef HAVE_EEZE #ifdef HAVE_EEZE
# include <Eeze.h> # include <Eeze.h>
#else #else
# include <EDBus.h> # include <Eldbus.h>
#endif #endif
typedef struct _Config Config; typedef struct _Config Config;
@ -96,7 +96,7 @@ struct _Battery
const char *model; const char *model;
const char *vendor; const char *vendor;
Eina_Bool got_prop:1; Eina_Bool got_prop:1;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
#ifdef __OpenBSD__ #ifdef __OpenBSD__
int * mib; int * mib;
#endif #endif
@ -107,7 +107,7 @@ struct _Ac_Adapter
const char *udi; const char *udi;
Eina_Bool present:1; Eina_Bool present:1;
const char *product; const char *product;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
#ifdef __OpenBSD__ #ifdef __OpenBSD__
int * mib; int * mib;
#endif #endif

166
src/modules/battery/e_mod_upower.c
View File

@ -9,15 +9,15 @@ extern Eina_List *device_batteries;
extern Eina_List *device_ac_adapters; extern Eina_List *device_ac_adapters;
extern double init_time; extern double init_time;
static EDBus_Connection *conn; static Eldbus_Connection *conn;
static EDBus_Proxy *upower_proxy; static Eldbus_Proxy *upower_proxy;
static void static void
_battery_free(Battery *bat) _battery_free(Battery *bat)
{ {
EDBus_Object *obj = edbus_proxy_object_get(bat->proxy); Eldbus_Object *obj = eldbus_proxy_object_get(bat->proxy);
edbus_proxy_unref(bat->proxy); eldbus_proxy_unref(bat->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
device_batteries = eina_list_remove(device_batteries, bat); device_batteries = eina_list_remove(device_batteries, bat);
eina_stringshare_del(bat->udi); eina_stringshare_del(bat->udi);
@ -31,9 +31,9 @@ _battery_free(Battery *bat)
static void static void
_ac_free(Ac_Adapter *ac) _ac_free(Ac_Adapter *ac)
{ {
EDBus_Object *obj = edbus_proxy_object_get(ac->proxy); Eldbus_Object *obj = eldbus_proxy_object_get(ac->proxy);
edbus_proxy_unref(ac->proxy); eldbus_proxy_unref(ac->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
device_ac_adapters = eina_list_remove(device_ac_adapters, ac); device_ac_adapters = eina_list_remove(device_ac_adapters, ac);
eina_stringshare_del(ac->udi); eina_stringshare_del(ac->udi);
@ -41,25 +41,25 @@ _ac_free(Ac_Adapter *ac)
} }
static void 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; 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; return;
while (edbus_message_iter_get_and_next(array, 'e', &dict)) while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{ {
const char *key; const char *key;
if (!edbus_message_iter_arguments_get(dict, "sv", &key, &variant)) if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant))
continue; continue;
if (!strcmp(key, "Online")) if (!strcmp(key, "Online"))
{ {
Eina_Bool b; Eina_Bool b;
edbus_message_iter_arguments_get(variant, "b", &b); eldbus_message_iter_arguments_get(variant, "b", &b);
ac->present = b; ac->present = b;
break; break;
} }
@ -68,28 +68,28 @@ _ac_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __UN
} }
static void 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; 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 static void
_process_ac(EDBus_Proxy *proxy) _process_ac(Eldbus_Proxy *proxy)
{ {
Ac_Adapter *ac; Ac_Adapter *ac;
ac = E_NEW(Ac_Adapter, 1); ac = E_NEW(Ac_Adapter, 1);
if (!ac) goto error; if (!ac) goto error;
ac->proxy = proxy; ac->proxy = proxy;
ac->udi = eina_stringshare_add(edbus_object_path_get(edbus_proxy_object_get(proxy))); ac->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy)));
edbus_proxy_property_get_all(proxy, _ac_get_all_cb, ac); eldbus_proxy_property_get_all(proxy, _ac_get_all_cb, ac);
edbus_proxy_signal_handler_add(proxy, "Changed", _ac_changed_cb, ac); eldbus_proxy_signal_handler_add(proxy, "Changed", _ac_changed_cb, ac);
device_ac_adapters = eina_list_append(device_ac_adapters, ac); device_ac_adapters = eina_list_append(device_ac_adapters, ac);
return; return;
error: error:
edbus_object_unref(edbus_proxy_object_get(proxy)); eldbus_object_unref(eldbus_proxy_object_get(proxy));
edbus_proxy_unref(proxy); eldbus_proxy_unref(proxy);
return; return;
} }
@ -104,15 +104,15 @@ static const char *bat_techologies[] = {
}; };
static void 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; Battery *bat = data;
EDBus_Message_Iter *array, *dict, *variant; Eldbus_Message_Iter *array, *dict, *variant;
bat->got_prop = EINA_TRUE; bat->got_prop = EINA_TRUE;
if (!edbus_message_arguments_get(msg, "a{sv}", &array)) if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
return; return;
while (edbus_message_iter_get_and_next(array, 'e', &dict)) while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{ {
const char *key; const char *key;
union union
@ -124,16 +124,16 @@ _bat_get_all_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U
const char *s; const char *s;
} val; } val;
if (!edbus_message_iter_arguments_get(dict, "sv", &key, &variant)) if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant))
continue; continue;
if (!strcmp(key, "IsPresent")) 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; bat->present = val.b;
} }
else if (!strcmp(key, "TimeToEmpty")) 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; bat->time_left = (int) val.i64;
if (bat->time_left > 0) if (bat->time_left > 0)
bat->charging = EINA_FALSE; 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")) 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; bat->percent = (int) val.d;
} }
else if (!strcmp(key, "Energy")) 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; bat->current_charge = (int) val.d;
} }
else if (!strcmp(key, "EnergyFullDesign")) 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; bat->design_charge = (int) val.d;
} }
else if (!strcmp(key, "EnergyFull")) 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; bat->last_full_charge = (int) val.d;
} }
else if (!strcmp(key, "TimeToFull")) 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; bat->time_full = (int) val.i64;
} }
else if (!strcmp(key, "Technology")) 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)) if (val.u > EINA_C_ARRAY_LENGTH(bat_techologies))
val.u = 0; val.u = 0;
bat->technology = bat_techologies[val.u]; bat->technology = bat_techologies[val.u];
} }
else if (!strcmp(key, "Model")) 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; continue;
eina_stringshare_replace(&bat->model, val.s); eina_stringshare_replace(&bat->model, val.s);
} }
else if (!strcmp(key, "Vendor")) 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; continue;
if (bat->vendor) if (bat->vendor)
eina_stringshare_del(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 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; 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 static void
_process_battery(EDBus_Proxy *proxy) _process_battery(Eldbus_Proxy *proxy)
{ {
Battery *bat; Battery *bat;
bat = E_NEW(Battery, 1); bat = E_NEW(Battery, 1);
if (!bat) if (!bat)
{ {
edbus_object_unref(edbus_proxy_object_get(proxy)); eldbus_object_unref(eldbus_proxy_object_get(proxy));
edbus_proxy_unref(proxy); eldbus_proxy_unref(proxy);
return; return;
} }
bat->proxy = proxy; bat->proxy = proxy;
bat->udi = eina_stringshare_add(edbus_object_path_get(edbus_proxy_object_get(proxy))); bat->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy)));
edbus_proxy_property_get_all(proxy, _bat_get_all_cb, bat); eldbus_proxy_property_get_all(proxy, _bat_get_all_cb, bat);
edbus_proxy_signal_handler_add(proxy, "Changed", _bat_changed_cb, bat); eldbus_proxy_signal_handler_add(proxy, "Changed", _bat_changed_cb, bat);
device_batteries = eina_list_append(device_batteries, bat); device_batteries = eina_list_append(device_batteries, bat);
_battery_device_update(); _battery_device_update();
} }
static void 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; Eldbus_Proxy *proxy = data;
EDBus_Message_Iter *variant; Eldbus_Message_Iter *variant;
EDBus_Object *obj; Eldbus_Object *obj;
unsigned int type; unsigned int type;
if (!edbus_message_arguments_get(msg, "v", &variant)) if (!eldbus_message_arguments_get(msg, "v", &variant))
goto error; goto error;
edbus_message_iter_arguments_get(variant, "u", &type); eldbus_message_iter_arguments_get(variant, "u", &type);
if (type == 1) if (type == 1)
_process_ac(proxy); _process_ac(proxy);
else if (type == 2) else if (type == 2)
@ -240,55 +240,55 @@ _device_type_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending __U
return; return;
error: error:
obj = edbus_proxy_object_get(proxy); obj = eldbus_proxy_object_get(proxy);
edbus_proxy_unref(proxy); eldbus_proxy_unref(proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
return; return;
} }
static void static void
_process_enumerate_path(const char *path) _process_enumerate_path(const char *path)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
obj = edbus_object_get(conn, BUS, path); obj = eldbus_object_get(conn, BUS, path);
EINA_SAFETY_ON_FALSE_RETURN(obj); EINA_SAFETY_ON_FALSE_RETURN(obj);
proxy = edbus_proxy_get(obj, "org.freedesktop.UPower.Device"); proxy = eldbus_proxy_get(obj, "org.freedesktop.UPower.Device");
edbus_proxy_property_get(proxy, "Type", _device_type_cb, proxy); eldbus_proxy_property_get(proxy, "Type", _device_type_cb, proxy);
} }
static void 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; 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; 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); _process_enumerate_path(path);
} }
static void 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; const char *path;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
_process_enumerate_path(path); _process_enumerate_path(path);
} }
static void static void
_device_removed_cb(void *data __UNUSED__, const EDBus_Message *msg) _device_removed_cb(void *data __UNUSED__, const Eldbus_Message *msg)
{ {
Battery *bat; Battery *bat;
Ac_Adapter *ac; Ac_Adapter *ac;
const char *path; const char *path;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
bat = _battery_battery_find(path); bat = _battery_battery_find(path);
if (bat) if (bat)
@ -308,26 +308,26 @@ _device_removed_cb(void *data __UNUSED__, const EDBus_Message *msg)
int int
_battery_upower_start(void) _battery_upower_start(void)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
edbus_init(); eldbus_init();
conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, 0); 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); 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); EINA_SAFETY_ON_NULL_GOTO(upower_proxy, proxy_error);
edbus_proxy_call(upower_proxy, "EnumerateDevices", _enumerate_cb, NULL, -1, ""); eldbus_proxy_call(upower_proxy, "EnumerateDevices", _enumerate_cb, NULL, -1, "");
edbus_proxy_signal_handler_add(upower_proxy, "DeviceAdded", _device_added_cb, NULL); eldbus_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_signal_handler_add(upower_proxy, "DeviceRemoved", _device_removed_cb, NULL);
return 1; return 1;
proxy_error: proxy_error:
edbus_object_unref(obj); eldbus_object_unref(obj);
obj_error: obj_error:
edbus_connection_unref(conn); eldbus_connection_unref(conn);
return 0; return 0;
} }
@ -337,16 +337,16 @@ _battery_upower_stop(void)
Eina_List *list, *list2; Eina_List *list, *list2;
Battery *bat; Battery *bat;
Ac_Adapter *ac; Ac_Adapter *ac;
EDBus_Object *obj; Eldbus_Object *obj;
EINA_LIST_FOREACH_SAFE(device_batteries, list, list2, bat) EINA_LIST_FOREACH_SAFE(device_batteries, list, list2, bat)
_battery_free(bat); _battery_free(bat);
EINA_LIST_FOREACH_SAFE(device_ac_adapters, list, list2, ac) EINA_LIST_FOREACH_SAFE(device_ac_adapters, list, list2, ac)
_ac_free(ac); _ac_free(ac);
obj = edbus_proxy_object_get(upower_proxy); obj = eldbus_proxy_object_get(upower_proxy);
edbus_proxy_unref(upower_proxy); eldbus_proxy_unref(upower_proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
edbus_connection_unref(conn); eldbus_connection_unref(conn);
edbus_shutdown(); eldbus_shutdown();
} }

140
src/modules/bluez4/agent.c
View File

@ -5,45 +5,45 @@
#define AGENT_INTERFACE "org.bluez.Agent" #define AGENT_INTERFACE "org.bluez.Agent"
#define BLUEZ_ERROR_FAILED "org.bluez.Error.Failed" #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 BLUEZ_ERROR_REJECTED "org.bluez.Error.Rejected"
#define REJECTED_MSG "Request was rejected" #define REJECTED_MSG "Request was rejected"
static EDBus_Connection *bluez_conn; static Eldbus_Connection *bluez_conn;
static char buf[1024]; static char buf[1024];
/* Local Functions */ /* Local Functions */
static void 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); eldbus_connection_send(bluez_conn, reply, NULL, NULL, -1);
edbus_message_unref(message); eldbus_message_unref(message);
} }
static void static void
_pincode_ok(void *data, char *text) _pincode_ok(void *data, char *text)
{ {
EDBus_Message *message = data; Eldbus_Message *message = data;
EDBus_Message *reply = edbus_message_method_return_new(message); Eldbus_Message *reply = eldbus_message_method_return_new(message);
edbus_message_arguments_append(reply, "s", text); eldbus_message_arguments_append(reply, "s", text);
_reply(message, reply); _reply(message, reply);
} }
static void static void
_passkey_ok(void *data, char *text) _passkey_ok(void *data, char *text)
{ {
EDBus_Message *message = data; Eldbus_Message *message = data;
uint32_t passkey = (uint32_t)atoi(text); uint32_t passkey = (uint32_t)atoi(text);
EDBus_Message *reply = edbus_message_method_return_new(message); Eldbus_Message *reply = eldbus_message_method_return_new(message);
edbus_message_arguments_append(reply, "u", passkey); eldbus_message_arguments_append(reply, "u", passkey);
_reply(message, reply); _reply(message, reply);
} }
static void static void
_cancel(void *data) _cancel(void *data)
{ {
EDBus_Message *message = data; Eldbus_Message *message = data;
EDBus_Message *reply = edbus_message_error_new(message, Eldbus_Message *reply = eldbus_message_error_new(message,
BLUEZ_ERROR_REJECTED, REJECTED_MSG); BLUEZ_ERROR_REJECTED, REJECTED_MSG);
_reply(message, reply); _reply(message, reply);
} }
@ -73,9 +73,9 @@ _display_msg(const char *title, const char *msg)
} }
static void 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); _reply(message, reply);
if (!dialog) return; if (!dialog) return;
e_object_del(E_OBJECT(dialog)); e_object_del(E_OBJECT(dialog));
@ -84,8 +84,8 @@ _reply_and_del_dialog(EDBus_Message *reply, E_Dialog *dialog)
static void static void
_reject(void *data, E_Dialog *dialog) _reject(void *data, E_Dialog *dialog)
{ {
const EDBus_Message *msg = dialog->data; const Eldbus_Message *msg = dialog->data;
EDBus_Message *reply = edbus_message_error_new(msg, BLUEZ_ERROR_REJECTED, Eldbus_Message *reply = eldbus_message_error_new(msg, BLUEZ_ERROR_REJECTED,
REJECTED_MSG); REJECTED_MSG);
_reply_and_del_dialog(reply, dialog); _reply_and_del_dialog(reply, dialog);
} }
@ -93,8 +93,8 @@ _reject(void *data, E_Dialog *dialog)
static void static void
_ok(void *data, E_Dialog *dialog) _ok(void *data, E_Dialog *dialog)
{ {
const EDBus_Message *msg = dialog->data; const Eldbus_Message *msg = dialog->data;
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
_reply_and_del_dialog(reply, dialog); _reply_and_del_dialog(reply, dialog);
} }
@ -107,10 +107,10 @@ _close(E_Win *win)
static void static void
_ask(const char *title, const char *ask_msg, const char *ok_label, _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"); 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_win_delete_callback_set(dialog->win, _close);
e_dialog_button_add(dialog, ok_label, NULL, _ok, NULL); e_dialog_button_add(dialog, ok_label, NULL, _ok, NULL);
e_dialog_button_add(dialog, "Reject", NULL, _reject, 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 */ /* Implementation of agent API */
static EDBus_Message * static Eldbus_Message *
_agent_release(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_release(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
DBG("Agent Released."); DBG("Agent Released.");
return edbus_message_method_return_new(message); return eldbus_message_method_return_new(message);
} }
static EDBus_Message * static Eldbus_Message *
_agent_request_pin_code(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_request_pin_code(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
EDBus_Message *msg = (EDBus_Message *)message; Eldbus_Message *msg = (Eldbus_Message *)message;
edbus_message_ref(msg); eldbus_message_ref(msg);
e_entry_dialog_show("Pin Code Requested", NULL, e_entry_dialog_show("Pin Code Requested", NULL,
"Enter the PinCode above. It should have 1-16 " "Enter the PinCode above. It should have 1-16 "
"characters and can be alphanumeric.", "0000", "characters and can be alphanumeric.", "0000",
@ -137,115 +137,115 @@ _agent_request_pin_code(const EDBus_Service_Interface *iface, const EDBus_Messag
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_agent_request_passkey(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_request_passkey(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
EDBus_Message *msg = (EDBus_Message *)message; Eldbus_Message *msg = (Eldbus_Message *)message;
edbus_message_ref(msg); eldbus_message_ref(msg);
e_entry_dialog_show("Passkey Requested", NULL, "Enter the Passkey above. " e_entry_dialog_show("Passkey Requested", NULL, "Enter the Passkey above. "
"It should be a numeric value between 0-999999.", "It should be a numeric value between 0-999999.",
"0", "OK", "Cancel", _passkey_ok, _cancel, msg); "0", "OK", "Cancel", _passkey_ok, _cancel, msg);
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_agent_display_passkey(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_display_passkey(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
const char *device; const char *device;
uint32_t passkey; uint32_t passkey;
uint16_t entered; uint16_t entered;
Device *dev; Device *dev;
if(!edbus_message_arguments_get(message, "ouq", &device, &passkey, &entered)) if(!eldbus_message_arguments_get(message, "ouq", &device, &passkey, &entered))
return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG);
dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); 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", snprintf(buf, sizeof(buf), "%d keys were typed on %s. Passkey is %06d",
entered, dev->name, passkey); entered, dev->name, passkey);
_display_msg("Display Passkey", buf); _display_msg("Display Passkey", buf);
return edbus_message_method_return_new(message); return eldbus_message_method_return_new(message);
} }
static EDBus_Message * static Eldbus_Message *
_agent_display_pin_code(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_display_pin_code(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
const char *device, *pincode; const char *device, *pincode;
Device *dev; Device *dev;
if(!edbus_message_arguments_get(message, "os", &device, &pincode)) if(!eldbus_message_arguments_get(message, "os", &device, &pincode))
return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG);
dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device);
snprintf(buf, sizeof(buf), "Pincode for %s is %s", dev->name, pincode); snprintf(buf, sizeof(buf), "Pincode for %s is %s", dev->name, pincode);
_display_msg("Display Pincode", buf); _display_msg("Display Pincode", buf);
return edbus_message_method_return_new(message); return eldbus_message_method_return_new(message);
} }
static EDBus_Message * static Eldbus_Message *
_agent_request_confirmation(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_request_confirmation(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
const char *device; const char *device;
uint32_t passkey; uint32_t passkey;
Device *dev; Device *dev;
if(!edbus_message_arguments_get(message, "ou", &device, &passkey)) if(!eldbus_message_arguments_get(message, "ou", &device, &passkey))
return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG);
dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device);
snprintf(buf, sizeof(buf), "%06d is the passkey presented in %s?", snprintf(buf, sizeof(buf), "%06d is the passkey presented in %s?",
passkey, dev->name); passkey, dev->name);
edbus_message_ref((EDBus_Message *)message); eldbus_message_ref((Eldbus_Message *)message);
_ask("Confirm Request", buf, "Confirm", (EDBus_Message *)message); _ask("Confirm Request", buf, "Confirm", (Eldbus_Message *)message);
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_agent_authorize(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_authorize(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
const char *device, *uuid; const char *device, *uuid;
Device *dev; Device *dev;
if(!edbus_message_arguments_get(message, "os", &device, &uuid)) if(!eldbus_message_arguments_get(message, "os", &device, &uuid))
return edbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG); return eldbus_message_error_new(message, BLUEZ_ERROR_FAILED, GET_ERROR_MSG);
dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device); dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, device);
snprintf(buf, sizeof(buf), "Grant permission for %s to connect?", snprintf(buf, sizeof(buf), "Grant permission for %s to connect?",
dev->name); dev->name);
edbus_message_ref((EDBus_Message *)message); eldbus_message_ref((Eldbus_Message *)message);
_ask("Authorize Connection", buf, "Grant", (EDBus_Message *)message); _ask("Authorize Connection", buf, "Grant", (Eldbus_Message *)message);
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_agent_cancel(const EDBus_Service_Interface *iface, const EDBus_Message *message) _agent_cancel(const Eldbus_Service_Interface *iface, const Eldbus_Message *message)
{ {
DBG("Request canceled."); 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 }, { "Release", NULL, NULL, _agent_release },
{ "RequestPinCode", EDBUS_ARGS({"o", "device"}), { "RequestPinCode", ELDBUS_ARGS({"o", "device"}),
EDBUS_ARGS({"s", "pincode"}), _agent_request_pin_code }, ELDBUS_ARGS({"s", "pincode"}), _agent_request_pin_code },
{ "RequestPasskey", EDBUS_ARGS({"o", "device"}), { "RequestPasskey", ELDBUS_ARGS({"o", "device"}),
EDBUS_ARGS({"u", "passkey"}), _agent_request_passkey }, ELDBUS_ARGS({"u", "passkey"}), _agent_request_passkey },
{ "DisplayPasskey", { "DisplayPasskey",
EDBUS_ARGS({"o", "device"},{"u", "passkey"},{"q", "entered"}), ELDBUS_ARGS({"o", "device"},{"u", "passkey"},{"q", "entered"}),
NULL, _agent_display_passkey }, NULL, _agent_display_passkey },
{ "DisplayPinCode", EDBUS_ARGS({"o", "device"},{"s", "pincode"}), { "DisplayPinCode", ELDBUS_ARGS({"o", "device"},{"s", "pincode"}),
NULL, _agent_display_pin_code }, NULL, _agent_display_pin_code },
{ "RequestConfirmation", EDBUS_ARGS({"o", "device"},{"u", "passkey"}), { "RequestConfirmation", ELDBUS_ARGS({"o", "device"},{"u", "passkey"}),
NULL, _agent_request_confirmation }, NULL, _agent_request_confirmation },
{ "Authorize", EDBUS_ARGS({"o", "device"},{"s", "uuid"}), { "Authorize", ELDBUS_ARGS({"o", "device"},{"s", "uuid"}),
NULL, _agent_authorize }, NULL, _agent_authorize },
{ "Cancel", NULL, NULL, _agent_cancel }, { "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 AGENT_INTERFACE, agent_methods
}; };
/* Public Functions */ /* Public Functions */
void ebluez4_register_agent_interfaces(EDBus_Connection *conn) void ebluez4_register_agent_interfaces(Eldbus_Connection *conn)
{ {
bluez_conn = conn; bluez_conn = conn;
edbus_service_interface_register(conn, AGENT_PATH, &agent_iface); eldbus_service_interface_register(conn, AGENT_PATH, &agent_iface);
edbus_service_interface_register(conn, REMOTE_AGENT_PATH, &agent_iface); eldbus_service_interface_register(conn, REMOTE_AGENT_PATH, &agent_iface);
} }

4
src/modules/bluez4/agent.h
View File

@ -1,6 +1,6 @@
#include "EDBus.h" #include "Eldbus.h"
#define AGENT_PATH "/org/bluez/Agent" #define AGENT_PATH "/org/bluez/Agent"
#define REMOTE_AGENT_PATH "/org/bluez/RemoteAgent" #define REMOTE_AGENT_PATH "/org/bluez/RemoteAgent"
void ebluez4_register_agent_interfaces(EDBus_Connection *conn); void ebluez4_register_agent_interfaces(Eldbus_Connection *conn);

6
src/modules/bluez4/e_mod_main.c
View File

@ -1,5 +1,5 @@
#include <e.h> #include <e.h>
#include <EDBus.h> #include <Eldbus.h>
#include "e_mod_main.h" #include "e_mod_main.h"
#include "ebluez4.h" #include "ebluez4.h"
@ -686,7 +686,7 @@ e_modapi_init(E_Module *m)
if (!ebluez4_config) if (!ebluez4_config)
ebluez4_config = E_NEW(Config, 1); ebluez4_config = E_NEW(Config, 1);
ebluez4_edbus_init(); ebluez4_eldbus_init();
e_gadcon_provider_register(&_gc_class); e_gadcon_provider_register(&_gc_class);
@ -721,7 +721,7 @@ e_modapi_shutdown(E_Module *m)
free(ebluez4_config); free(ebluez4_config);
ebluez4_config = NULL; ebluez4_config = NULL;
ebluez4_edbus_shutdown(); ebluez4_eldbus_shutdown();
e_gadcon_provider_unregister(&_gc_class); e_gadcon_provider_unregister(&_gc_class);
return 1; return 1;
} }

268
src/modules/bluez4/ebluez4.c
View File

@ -32,7 +32,7 @@ _adap_path_cmp(const void *d1, const void *d2)
const Adapter *adap = d1; const Adapter *adap = d1;
const char *path = d2; 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 static struct icon_type
@ -71,12 +71,12 @@ _icon_to_type(const char *icon)
static void static void
_free_dev(Device *dev) _free_dev(Device *dev)
{ {
if (dev->proxy.input) edbus_proxy_unref(dev->proxy.input); if (dev->proxy.input) eldbus_proxy_unref(dev->proxy.input);
if (dev->proxy.audio_source) edbus_proxy_unref(dev->proxy.audio_source); if (dev->proxy.audio_source) eldbus_proxy_unref(dev->proxy.audio_source);
if (dev->proxy.audio_sink) edbus_proxy_unref(dev->proxy.audio_sink); if (dev->proxy.audio_sink) eldbus_proxy_unref(dev->proxy.audio_sink);
if (dev->obj) if (dev->obj)
edbus_object_unref(dev->obj); eldbus_object_unref(dev->obj);
eina_stringshare_del(dev->addr); eina_stringshare_del(dev->addr);
dev->addr = NULL; dev->addr = NULL;
eina_stringshare_del(dev->name); eina_stringshare_del(dev->name);
@ -87,8 +87,8 @@ _free_dev(Device *dev)
static void static void
_free_adap(Adapter *adap) _free_adap(Adapter *adap)
{ {
edbus_proxy_unref(adap->proxy); eldbus_proxy_unref(adap->proxy);
edbus_object_unref(adap->obj); eldbus_object_unref(adap->obj);
eina_stringshare_del(adap->name); eina_stringshare_del(adap->name);
adap->name = NULL; adap->name = NULL;
ebluez4_adapter_settings_del(adap->dialog); ebluez4_adapter_settings_del(adap->dialog);
@ -127,25 +127,25 @@ _uuid_to_profile(const char *uuid)
} }
static void static void
_set_dev_services(Device *dev, EDBus_Message_Iter *uuids) _set_dev_services(Device *dev, Eldbus_Message_Iter *uuids)
{ {
const char *uuid; 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)) switch (_uuid_to_profile(uuid))
{ {
case INPUT: case INPUT:
if (!dev->proxy.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; break;
case AUDIO_SOURCE: case AUDIO_SOURCE:
if (!dev->proxy.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); AUDIO_SOURCE_INTERFACE);
break; break;
case AUDIO_SINK: case AUDIO_SINK:
if (!dev->proxy.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); AUDIO_SINK_INTERFACE);
break; break;
default: default:
@ -154,65 +154,65 @@ _set_dev_services(Device *dev, EDBus_Message_Iter *uuids)
} }
static void 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, 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; const char *key;
*icon = NULL; *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; return;
if (!strcmp(key, "Address")) if (!strcmp(key, "Address"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", addr)) if (!eldbus_message_iter_arguments_get(variant, "s", addr))
return; return;
} }
else if (!strcmp(key, "Name")) else if (!strcmp(key, "Name"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", name)) if (!eldbus_message_iter_arguments_get(variant, "s", name))
return; return;
} }
else if (!strcmp(key, "Icon")) else if (!strcmp(key, "Icon"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", icon)) if (!eldbus_message_iter_arguments_get(variant, "s", icon))
return; return;
} }
else if (!strcmp(key, "Paired")) else if (!strcmp(key, "Paired"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", paired)) if (!eldbus_message_iter_arguments_get(variant, "b", paired))
return; return;
} }
else if (!strcmp(key, "Connected")) else if (!strcmp(key, "Connected"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", connected)) if (!eldbus_message_iter_arguments_get(variant, "b", connected))
return; return;
} }
else if (!strcmp(key, "UUIDs")) else if (!strcmp(key, "UUIDs"))
{ {
if (!edbus_message_iter_arguments_get(variant, "as", uuids)) if (!eldbus_message_iter_arguments_get(variant, "as", uuids))
return; return;
} }
} }
} }
static void 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; const char *key, *name, *icon;
char err_msg[4096]; char err_msg[4096];
Eina_Bool paired, connected; Eina_Bool paired, connected;
EDBus_Message_Iter *variant, *uuids; Eldbus_Message_Iter *variant, *uuids;
Device *dev = context; Device *dev = context;
Device *found_dev = eina_list_search_unsorted(ctxt->found_devices, Device *found_dev = eina_list_search_unsorted(ctxt->found_devices,
_dev_addr_cmp, dev->addr); _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), snprintf(err_msg, sizeof(err_msg),
"Property of %s changed, but could not be read", dev->name); "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 (!strcmp(key, "Name"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", &name)) if (!eldbus_message_iter_arguments_get(variant, "s", &name))
return; return;
DBG("'%s' property of %s changed to %s", key, dev->name, name); DBG("'%s' property of %s changed to %s", key, dev->name, name);
eina_stringshare_replace(&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")) else if (!strcmp(key, "Icon"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", &icon)) if (!eldbus_message_iter_arguments_get(variant, "s", &icon))
return; return;
if (!found_dev) return; if (!found_dev) return;
DBG("'%s' property of %s changed to %s", key, found_dev->name, icon); 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")) else if (!strcmp(key, "Paired"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &paired)) if (!eldbus_message_iter_arguments_get(variant, "b", &paired))
return; return;
DBG("'%s' property of %s changed to %d", key, dev->name, paired); DBG("'%s' property of %s changed to %d", key, dev->name, paired);
dev->paired = paired; dev->paired = paired;
@ -258,25 +258,25 @@ _on_dev_property_changed(void *context, const EDBus_Message *msg)
} }
else if (!strcmp(key, "Connected")) else if (!strcmp(key, "Connected"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &connected)) if (!eldbus_message_iter_arguments_get(variant, "b", &connected))
return; return;
DBG("'%s' property of %s changed to %d", key, dev->name, connected); DBG("'%s' property of %s changed to %d", key, dev->name, connected);
dev->connected = connected; dev->connected = connected;
} }
else if (!strcmp(key, "UUIDs")) else if (!strcmp(key, "UUIDs"))
{ {
if (!edbus_message_iter_arguments_get(variant, "as", &uuids)) if (!eldbus_message_iter_arguments_get(variant, "as", &uuids))
return; return;
_set_dev_services(dev, uuids); _set_dev_services(dev, uuids);
} }
} }
static void 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; 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); ERR("%s: %s", err_name, err_msg);
ebluez4_show_error(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 static void
_try_to_connect(EDBus_Proxy *proxy) _try_to_connect(Eldbus_Proxy *proxy)
{ {
if (proxy) if (proxy)
edbus_proxy_call(proxy, "Connect", _on_connected, NULL, -1, ""); eldbus_proxy_call(proxy, "Connect", _on_connected, NULL, -1, "");
} }
static void 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; 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); ERR("%s: %s", err_name, err_msg);
ebluez4_show_error(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 static void
_try_to_disconnect(EDBus_Proxy *proxy) _try_to_disconnect(Eldbus_Proxy *proxy)
{ {
if (proxy) if (proxy)
edbus_proxy_call(proxy, "Disconnect", _on_disconnected, NULL, -1, ""); eldbus_proxy_call(proxy, "Disconnect", _on_disconnected, NULL, -1, "");
} }
static void 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; const char *err_name, *err_msg;
Pair_Cb *d = data; Pair_Cb *d = data;
Eina_Bool success = EINA_TRUE; 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); ERR("%s: %s", err_name, err_msg);
success = EINA_FALSE; success = EINA_FALSE;
@ -328,15 +328,15 @@ _on_paired(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
} }
static void 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; const char *addr, *name, *icon;
Eina_Bool paired; Eina_Bool paired;
Eina_Bool connected; Eina_Bool connected;
Device *dev = data; Device *dev = data;
if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) if (!eldbus_message_arguments_get(msg, "a{sv}", &dict))
return; return;
_retrieve_properties(dict, &addr, &name, &icon, &paired, &connected, &uuids); _retrieve_properties(dict, &addr, &name, &icon, &paired, &connected, &uuids);
@ -363,22 +363,22 @@ _set_dev(const char *path)
{ {
Device *dev = calloc(1, sizeof(Device)); Device *dev = calloc(1, sizeof(Device));
dev->obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, path); dev->obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, path);
dev->proxy.dev = edbus_proxy_get(dev->obj, DEVICE_INTERFACE); dev->proxy.dev = eldbus_proxy_get(dev->obj, DEVICE_INTERFACE);
edbus_proxy_call(dev->proxy.dev, "GetProperties", _on_dev_properties, dev, eldbus_proxy_call(dev->proxy.dev, "GetProperties", _on_dev_properties, dev,
-1, ""); -1, "");
edbus_proxy_signal_handler_add(dev->proxy.dev, "PropertyChanged", eldbus_proxy_signal_handler_add(dev->proxy.dev, "PropertyChanged",
_on_dev_property_changed, dev); _on_dev_property_changed, dev);
ctxt->devices = eina_list_append(ctxt->devices, dev); ctxt->devices = eina_list_append(ctxt->devices, dev);
} }
static void static void
_on_removed(void *context, const EDBus_Message *msg) _on_removed(void *context, const Eldbus_Message *msg)
{ {
const char *path; const char *path;
Device *dev, *fdev; Device *dev, *fdev;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
dev = eina_list_search_unsorted(ctxt->devices, ebluez4_dev_path_cmp, path); 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 static void
_on_created(void *context, const EDBus_Message *msg) _on_created(void *context, const Eldbus_Message *msg)
{ {
const char *path; const char *path;
if (!edbus_message_arguments_get(msg, "o", &path)) if (!eldbus_message_arguments_get(msg, "o", &path))
return; return;
_set_dev(path); _set_dev(path);
} }
static void 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; const char *addr, *name, *icon;
Eina_Bool paired, connected; Eina_Bool paired, connected;
Device *dev; Device *dev;
if (!edbus_message_arguments_get(msg, "sa{sv}", &addr, &dict)) if (!eldbus_message_arguments_get(msg, "sa{sv}", &addr, &dict))
return; return;
if (eina_list_search_unsorted(ctxt->found_devices, _dev_addr_cmp, addr)) 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 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 *path;
const char *err_msg = "Error reading list of devices"; 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); ERR("%s", err_msg);
ebluez4_show_error("Bluez Error", err_msg); ebluez4_show_error("Bluez Error", err_msg);
return; return;
} }
while (edbus_message_iter_get_and_next(array, 'o', &path)) while (eldbus_message_iter_get_and_next(array, 'o', &path))
_set_dev(path); _set_dev(path);
} }
static void 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; const char *key, *name;
char err_msg[1096]; char err_msg[1096];
Eina_Bool visible, pairable, powered; Eina_Bool visible, pairable, powered;
EDBus_Message_Iter *variant; Eldbus_Message_Iter *variant;
Adapter *adap = context; 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), snprintf(err_msg, sizeof(err_msg),
"Property of %s changed, but could not be read", adap->name); "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 (!strcmp(key, "Name"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", &name)) if (!eldbus_message_iter_arguments_get(variant, "s", &name))
return; return;
DBG("'%s' property of %s changed to %s", key, adap->name, name); DBG("'%s' property of %s changed to %s", key, adap->name, name);
eina_stringshare_del(adap->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")) else if (!strcmp(key, "Discoverable"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &visible)) if (!eldbus_message_iter_arguments_get(variant, "b", &visible))
return; return;
DBG("'%s' property of %s changed to %d", key, adap->name, visible); DBG("'%s' property of %s changed to %d", key, adap->name, visible);
adap->visible = visible; adap->visible = visible;
} }
else if (!strcmp(key, "Pairable")) else if (!strcmp(key, "Pairable"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &pairable)) if (!eldbus_message_iter_arguments_get(variant, "b", &pairable))
return; return;
DBG("'%s' property of %s changed to %d", key, adap->name, pairable); DBG("'%s' property of %s changed to %d", key, adap->name, pairable);
adap->pairable = pairable; adap->pairable = pairable;
} }
else if (!strcmp(key, "Powered")) else if (!strcmp(key, "Powered"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &powered)) if (!eldbus_message_iter_arguments_get(variant, "b", &powered))
return; return;
DBG("'%s' property of %s changed to %d", key, adap->name, powered); DBG("'%s' property of %s changed to %d", key, adap->name, powered);
adap->powered = powered; adap->powered = powered;
@ -498,39 +498,39 @@ _on_adap_property_changed(void *context, const EDBus_Message *msg)
} }
static void 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; const char *name, *key;
Eina_Bool visible, pairable, powered; Eina_Bool visible, pairable, powered;
Adapter *adap = data; Adapter *adap = data;
if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) if (!eldbus_message_arguments_get(msg, "a{sv}", &dict))
return; 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; return;
else if (!strcmp(key, "Name")) else if (!strcmp(key, "Name"))
{ {
if (!edbus_message_iter_arguments_get(variant, "s", &name)) if (!eldbus_message_iter_arguments_get(variant, "s", &name))
return; return;
} }
else if (!strcmp(key, "Discoverable")) else if (!strcmp(key, "Discoverable"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &visible)) if (!eldbus_message_iter_arguments_get(variant, "b", &visible))
return; return;
} }
else if (!strcmp(key, "Pairable")) else if (!strcmp(key, "Pairable"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &pairable)) if (!eldbus_message_iter_arguments_get(variant, "b", &pairable))
return; return;
} }
else if (!strcmp(key, "Powered")) else if (!strcmp(key, "Powered"))
{ {
if (!edbus_message_iter_arguments_get(variant, "b", &powered)) if (!eldbus_message_iter_arguments_get(variant, "b", &powered))
return; return;
} }
} }
@ -545,12 +545,12 @@ _on_adap_properties(void *data, const EDBus_Message *msg, EDBus_Pending *pending
static void static void
_unset_default_adapter(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); _free_dev_list(&ctxt->devices);
ctxt->devices = NULL; ctxt->devices = NULL;
_free_dev_list(&ctxt->found_devices); _free_dev_list(&ctxt->found_devices);
ctxt->found_devices = NULL; ctxt->found_devices = NULL;
edbus_object_unref(ctxt->adap_obj); eldbus_object_unref(ctxt->adap_obj);
ctxt->adap_obj = NULL; ctxt->adap_obj = NULL;
ebluez4_update_all_gadgets_visibility(); ebluez4_update_all_gadgets_visibility();
} }
@ -564,7 +564,7 @@ _unset_adapter(const char *path)
if (!adap) if (!adap)
return; return;
if (!strcmp(edbus_object_path_get(ctxt->adap_obj), path)) if (!strcmp(eldbus_object_path_get(ctxt->adap_obj), path))
_unset_default_adapter(); _unset_default_adapter();
ctxt->adapters = eina_list_remove(ctxt->adapters, adap); ctxt->adapters = eina_list_remove(ctxt->adapters, adap);
_free_adap(adap); _free_adap(adap);
@ -576,45 +576,45 @@ _set_adapter(const char *path)
{ {
Adapter *adap = calloc(1, sizeof(Adapter)); 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) if (ctxt->adap_obj && adap->obj == ctxt->adap_obj)
adap->is_default = EINA_TRUE; adap->is_default = EINA_TRUE;
else else
adap->is_default = EINA_FALSE; adap->is_default = EINA_FALSE;
adap->proxy = edbus_proxy_get(adap->obj, ADAPTER_INTERFACE); adap->proxy = eldbus_proxy_get(adap->obj, ADAPTER_INTERFACE);
edbus_proxy_call(adap->proxy, "GetProperties", _on_adap_properties, adap, -1, 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); _on_adap_property_changed, adap);
ctxt->adapters = eina_list_append(ctxt->adapters, adap); ctxt->adapters = eina_list_append(ctxt->adapters, adap);
} }
static void 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 *path;
const char *err_msg = "Error reading list of adapters"; 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); ERR("%s", err_msg);
ebluez4_show_error("Bluez Error", err_msg); ebluez4_show_error("Bluez Error", err_msg);
return; return;
} }
while (edbus_message_iter_get_and_next(array, 'o', &path)) while (eldbus_message_iter_get_and_next(array, 'o', &path))
_set_adapter(path); _set_adapter(path);
} }
static void static void
_set_default_adapter(const EDBus_Message *msg) _set_default_adapter(const Eldbus_Message *msg)
{ {
Adapter *adap; Adapter *adap;
const char *adap_path; const char *adap_path;
const char *err_msg = "Error reading path of Default Adapter"; 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); ERR("%s", err_msg);
ebluez4_show_error("Bluez Error", err_msg); ebluez4_show_error("Bluez Error", err_msg);
@ -630,24 +630,24 @@ _set_default_adapter(const EDBus_Message *msg)
if (adap) if (adap)
adap->is_default = EINA_TRUE; adap->is_default = EINA_TRUE;
ctxt->adap_obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, adap_path); ctxt->adap_obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, adap_path);
ctxt->adap_proxy = edbus_proxy_get(ctxt->adap_obj, ADAPTER_INTERFACE); 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); _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); _on_created, NULL);
edbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceRemoved", eldbus_proxy_signal_handler_add(ctxt->adap_proxy, "DeviceRemoved",
_on_removed, NULL); _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"); REMOTE_AGENT_PATH, "KeyboardDisplay");
ebluez4_update_all_gadgets_visibility(); ebluez4_update_all_gadgets_visibility();
} }
static void 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; 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 * If bluetoothd is starting up, we can fail here and wait for the
* DefaultAdapterChanged signal later * DefaultAdapterChanged signal later
*/ */
if (edbus_message_error_get(msg, &err_name, &err_msg)) if (eldbus_message_error_get(msg, &err_name, &err_msg))
return; return;
if (!ctxt->adap_obj) if (!ctxt->adap_obj)
@ -663,18 +663,18 @@ _default_adapter_get(void *data, const EDBus_Message *msg, EDBus_Pending *pendin
} }
static void 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); _set_default_adapter(msg);
} }
static void 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 *adap_path;
const char *err_msg = "Error reading path of Removed Adapter"; 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); ERR("%s", err_msg);
ebluez4_show_error("Bluez Error", err_msg); ebluez4_show_error("Bluez Error", err_msg);
@ -685,12 +685,12 @@ _on_adapter_removed(void *context, const EDBus_Message *msg)
} }
static void 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 *adap_path;
const char *err_msg = "Error reading path of Added Adapter"; 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); ERR("%s", err_msg);
ebluez4_show_error("Bluez Error", 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,"")) if (!strcmp(old_id,"") && strcmp(new_id,""))
{ {
// Bluez up // Bluez up
edbus_proxy_call(ctxt->man_proxy, "DefaultAdapter", eldbus_proxy_call(ctxt->man_proxy, "DefaultAdapter",
_default_adapter_get, NULL, -1, ""); _default_adapter_get, NULL, -1, "");
edbus_proxy_call(ctxt->man_proxy, "ListAdapters", eldbus_proxy_call(ctxt->man_proxy, "ListAdapters",
_on_list_adapters, NULL, -1, ""); _on_list_adapters, NULL, -1, "");
} }
else if (strcmp(old_id,"") && !strcmp(new_id,"")) 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 */ /* Public Functions */
void void
ebluez4_edbus_init(void) ebluez4_eldbus_init(void)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
ctxt = calloc(1, sizeof(Context)); ctxt = calloc(1, sizeof(Context));
edbus_init(); eldbus_init();
ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
obj = edbus_object_get(ctxt->conn, BLUEZ_BUS, MANAGER_PATH); obj = eldbus_object_get(ctxt->conn, BLUEZ_BUS, MANAGER_PATH);
ctxt->man_proxy = edbus_proxy_get(obj, MANAGER_INTERFACE); ctxt->man_proxy = eldbus_proxy_get(obj, MANAGER_INTERFACE);
ebluez4_register_agent_interfaces(ctxt->conn); 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); _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); _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); _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); NULL, EINA_TRUE);
} }
void void
ebluez4_edbus_shutdown(void) ebluez4_eldbus_shutdown(void)
{ {
if (ctxt->adap_obj) if (ctxt->adap_obj)
_unset_default_adapter(); _unset_default_adapter();
_free_adap_list(); _free_adap_list();
edbus_object_unref(edbus_proxy_object_get(ctxt->man_proxy)); eldbus_object_unref(eldbus_proxy_object_get(ctxt->man_proxy));
edbus_connection_unref(ctxt->conn); eldbus_connection_unref(ctxt->conn);
free(ctxt); free(ctxt);
edbus_shutdown(); eldbus_shutdown();
} }
void void
@ -764,13 +764,13 @@ ebluez4_start_discovery(void)
{ {
_free_dev_list(&ctxt->found_devices); _free_dev_list(&ctxt->found_devices);
ebluez4_update_instances(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 void
ebluez4_stop_discovery(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 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); EINA_SAFETY_ON_NULL_RETURN(d);
d->cb = cb; d->cb = cb;
d->data = data; 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"); -1, "sos", addr, AGENT_PATH, "KeyboardDisplay");
} }
void void
ebluez4_remove_device(EDBus_Object *obj) ebluez4_remove_device(Eldbus_Object *obj)
{ {
edbus_proxy_call(ctxt->adap_proxy, "RemoveDevice", NULL, NULL, -1, "o", eldbus_proxy_call(ctxt->adap_proxy, "RemoveDevice", NULL, NULL, -1, "o",
edbus_object_path_get(obj)); eldbus_object_path_get(obj));
} }
int int
@ -813,22 +813,22 @@ ebluez4_dev_path_cmp(const void *d1, const void *d2)
const Device *dev = d1; const Device *dev = d1;
const char *path = d2; const char *path = d2;
return strcmp(edbus_object_path_get(dev->obj), path); return strcmp(eldbus_object_path_get(dev->obj), path);
} }
void void
ebluez4_adapter_property_set(Adapter *adap, const char *prop_name, Eina_Bool value) ebluez4_adapter_property_set(Adapter *adap, const char *prop_name, Eina_Bool value)
{ {
EDBus_Message_Iter *variant, *iter; Eldbus_Message_Iter *variant, *iter;
EDBus_Message *new_msg; Eldbus_Message *new_msg;
if (!adap) return; if (!adap) return;
if (!adap->obj) return; if (!adap->obj) return;
new_msg = edbus_proxy_method_call_new(adap->proxy, "SetProperty"); new_msg = eldbus_proxy_method_call_new(adap->proxy, "SetProperty");
iter = edbus_message_iter_get(new_msg); iter = eldbus_message_iter_get(new_msg);
edbus_message_iter_basic_append(iter, 's', prop_name); eldbus_message_iter_basic_append(iter, 's', prop_name);
variant = edbus_message_iter_container_new(iter, 'v', "b"); variant = eldbus_message_iter_container_new(iter, 'v', "b");
edbus_message_iter_basic_append(variant, 'b', value); eldbus_message_iter_basic_append(variant, 'b', value);
edbus_message_iter_container_close(iter, variant); eldbus_message_iter_container_close(iter, variant);
edbus_proxy_send(adap->proxy, new_msg, NULL, NULL, -1); eldbus_proxy_send(adap->proxy, new_msg, NULL, NULL, -1);
} }

30
src/modules/bluez4/ebluez4.h
View File

@ -1,4 +1,4 @@
#include "EDBus.h" #include "Eldbus.h"
#define BLUEZ_BUS "org.bluez" #define BLUEZ_BUS "org.bluez"
#define MANAGER_PATH "/" #define MANAGER_PATH "/"
@ -34,13 +34,13 @@ typedef struct _Device
const char *type; const char *type;
Eina_Bool paired; Eina_Bool paired;
Eina_Bool connected; Eina_Bool connected;
EDBus_Object *obj; Eldbus_Object *obj;
struct struct
{ {
EDBus_Proxy *dev; Eldbus_Proxy *dev;
EDBus_Proxy *input; Eldbus_Proxy *input;
EDBus_Proxy *audio_sink; Eldbus_Proxy *audio_sink;
EDBus_Proxy *audio_source; Eldbus_Proxy *audio_source;
} proxy; } proxy;
} Device; } Device;
@ -55,16 +55,16 @@ typedef struct _Adapter
int powered_checked; int powered_checked;
Eina_Bool is_default; Eina_Bool is_default;
E_Dialog *dialog; E_Dialog *dialog;
EDBus_Object *obj; Eldbus_Object *obj;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
} Adapter; } Adapter;
typedef struct _Context typedef struct _Context
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Object *adap_obj; Eldbus_Object *adap_obj;
EDBus_Proxy *man_proxy; Eldbus_Proxy *man_proxy;
EDBus_Proxy *adap_proxy; Eldbus_Proxy *adap_proxy;
Eina_List *devices; Eina_List *devices;
Eina_List *found_devices; Eina_List *found_devices;
Eina_List *adapters; Eina_List *adapters;
@ -72,13 +72,13 @@ typedef struct _Context
Context *ctxt; Context *ctxt;
void ebluez4_edbus_init(void); void ebluez4_eldbus_init(void);
void ebluez4_edbus_shutdown(void); void ebluez4_eldbus_shutdown(void);
void ebluez4_start_discovery(void); void ebluez4_start_discovery(void);
void ebluez4_stop_discovery(void); void ebluez4_stop_discovery(void);
void ebluez4_connect_to_device(Device *dev); void ebluez4_connect_to_device(Device *dev);
void ebluez4_disconnect_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_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); 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); void ebluez4_adapter_property_set(Adapter *adap, const char *prop_name, Eina_Bool value);

20
src/modules/connman/E_Connman.h
View File

@ -3,7 +3,7 @@
#include "e.h" #include "e.h"
#include <stdbool.h> #include <stdbool.h>
#include <EDBus.h> #include <Eldbus.h>
typedef struct _E_Connman_Agent E_Connman_Agent; typedef struct _E_Connman_Agent E_Connman_Agent;
@ -32,8 +32,8 @@ enum Connman_Service_Type
struct Connman_Manager struct Connman_Manager
{ {
const char *path; const char *path;
EDBus_Proxy *technology_iface; Eldbus_Proxy *technology_iface;
EDBus_Proxy *manager_iface; Eldbus_Proxy *manager_iface;
Eina_Inlist *services; /* The prioritized list of services */ Eina_Inlist *services; /* The prioritized list of services */
@ -45,16 +45,16 @@ struct Connman_Manager
/* Private */ /* Private */
struct struct
{ {
EDBus_Pending *get_services; Eldbus_Pending *get_services;
EDBus_Pending *get_wifi_properties; Eldbus_Pending *get_wifi_properties;
EDBus_Pending *set_powered; Eldbus_Pending *set_powered;
} pending; } pending;
}; };
struct Connman_Service struct Connman_Service
{ {
const char *path; const char *path;
EDBus_Proxy *service_iface; Eldbus_Proxy *service_iface;
EINA_INLIST; EINA_INLIST;
/* Properties */ /* Properties */
@ -67,8 +67,8 @@ struct Connman_Service
/* Private */ /* Private */
struct struct
{ {
EDBus_Pending *connect; Eldbus_Pending *connect;
EDBus_Pending *disconnect; Eldbus_Pending *disconnect;
void *data; void *data;
} pending; } pending;
}; };
@ -79,7 +79,7 @@ extern int E_CONNMAN_EVENT_MANAGER_OUT;
/* Daemon monitoring */ /* 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); unsigned int e_connman_system_shutdown(void);
/* Requests from UI */ /* Requests from UI */

154
src/modules/connman/agent.c
View File

@ -34,23 +34,23 @@ struct _E_Connman_Agent_Input
struct _E_Connman_Agent struct _E_Connman_Agent
{ {
E_Dialog *dialog; E_Dialog *dialog;
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
EDBus_Message *msg; Eldbus_Message *msg;
EDBus_Connection *conn; Eldbus_Connection *conn;
Eina_Bool canceled:1; Eina_Bool canceled:1;
}; };
static void 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); eldbus_message_iter_arguments_append(array, "{sv}", &dict);
edbus_message_iter_basic_append(dict, 's', key); eldbus_message_iter_basic_append(dict, 's', key);
variant = edbus_message_iter_container_new(dict, 'v', "s"); variant = eldbus_message_iter_container_new(dict, 'v', "s");
edbus_message_iter_basic_append(variant, 's', val); eldbus_message_iter_basic_append(variant, 's', val);
edbus_message_iter_container_close(dict, variant); eldbus_message_iter_container_close(dict, variant);
edbus_message_iter_container_close(array, dict); eldbus_message_iter_container_close(array, dict);
} }
static void static void
@ -59,9 +59,9 @@ _dialog_ok_cb(void *data, E_Dialog *dialog)
E_Connman_Agent *agent = data; E_Connman_Agent *agent = data;
E_Connman_Agent_Input *input; E_Connman_Agent_Input *input;
Evas_Object *toolbook, *list; Evas_Object *toolbook, *list;
EDBus_Message_Iter *iter, *array; Eldbus_Message_Iter *iter, *array;
Eina_List *input_list, *l; Eina_List *input_list, *l;
EDBus_Message *reply; Eldbus_Message *reply;
toolbook = agent->dialog->content_object; toolbook = agent->dialog->content_object;
@ -81,15 +81,15 @@ _dialog_ok_cb(void *data, E_Dialog *dialog)
agent->canceled = EINA_FALSE; agent->canceled = EINA_FALSE;
input_list = evas_object_data_get(list, "input_list"); input_list = evas_object_data_get(list, "input_list");
reply = edbus_message_method_return_new(agent->msg); reply = eldbus_message_method_return_new(agent->msg);
iter = edbus_message_iter_get(reply); iter = eldbus_message_iter_get(reply);
edbus_message_iter_arguments_append(iter, "a{sv}", &array); eldbus_message_iter_arguments_append(iter, "a{sv}", &array);
EINA_LIST_FOREACH(input_list, l, input) EINA_LIST_FOREACH(input_list, l, input)
_dict_append_basic(array, input->key, input->value); _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)); 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 static void
_dialog_cancel(E_Connman_Agent *agent) _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", "net.connman.Agent.Error.Canceled",
"User canceled dialog"); "User canceled dialog");
edbus_connection_send(agent->conn, reply, NULL, NULL, -1); eldbus_connection_send(agent->conn, reply, NULL, NULL, -1);
} }
static void static void
@ -136,7 +136,7 @@ _dialog_del_cb(void *data)
_dialog_cancel(agent); _dialog_cancel(agent);
// FIXME need to mark cs->pending_connect = NULL; // FIXME need to mark cs->pending_connect = NULL;
edbus_message_unref(agent->msg); eldbus_message_unref(agent->msg);
agent->dialog = NULL; agent->dialog = NULL;
} }
@ -277,18 +277,18 @@ _dialog_new(E_Connman_Agent *agent)
return dialog; return dialog;
} }
static EDBus_Message * static Eldbus_Message *
_agent_release(const EDBus_Service_Interface *iface, _agent_release(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
E_Connman_Agent *agent; E_Connman_Agent *agent;
EDBus_Message *reply; Eldbus_Message *reply;
DBG("Agent released"); 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); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply);
if (agent->dialog) if (agent->dialog)
@ -297,35 +297,35 @@ _agent_release(const EDBus_Service_Interface *iface,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
_agent_report_error(const EDBus_Service_Interface *iface, _agent_report_error(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
return NULL; return NULL;
} }
static EDBus_Message * static Eldbus_Message *
_agent_request_browser(const EDBus_Service_Interface *iface, _agent_request_browser(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
return NULL; return NULL;
} }
static Eina_Bool static Eina_Bool
_parse_field_value(struct Connman_Field *field, const char *key, _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")) if (!strcmp(key, "Type"))
{ {
EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); 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; return EINA_TRUE;
} }
if (!strcmp(key, "Requirement")) if (!strcmp(key, "Requirement"))
{ {
EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); 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; return EINA_TRUE;
} }
@ -339,7 +339,7 @@ _parse_field_value(struct Connman_Field *field, const char *key,
if (!strcmp(key, "Value")) if (!strcmp(key, "Value"))
{ {
EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); 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; return EINA_TRUE;
} }
@ -348,23 +348,23 @@ _parse_field_value(struct Connman_Field *field, const char *key,
} }
static Eina_Bool 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) 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); 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; const char *key;
char *sig2; 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; return EINA_FALSE;
sig2 = edbus_message_iter_signature_get(var); sig2 = eldbus_message_iter_signature_get(var);
if (!sig2) if (!sig2)
return EINA_FALSE; return EINA_FALSE;
@ -379,26 +379,26 @@ _parse_field(struct Connman_Field *field, EDBus_Message_Iter *value,
return EINA_TRUE; return EINA_TRUE;
} }
static EDBus_Message * static Eldbus_Message *
_agent_request_input(const EDBus_Service_Interface *iface, _agent_request_input(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
E_Connman_Module_Context *ctxt = connman_mod->data; E_Connman_Module_Context *ctxt = connman_mod->data;
const Eina_List *l; const Eina_List *l;
E_Connman_Instance *inst; E_Connman_Instance *inst;
EDBus_Message_Iter *array, *dict; Eldbus_Message_Iter *array, *dict;
E_Connman_Agent *agent; E_Connman_Agent *agent;
const char *path; const char *path;
agent = edbus_service_object_data_get(iface, AGENT_KEY); agent = eldbus_service_object_data_get(iface, AGENT_KEY);
/* Discard previous requests */ /* Discard previous requests */
// if msg is the current agent msg? eek. // if msg is the current agent msg? eek.
if (agent->msg == msg) return NULL; if (agent->msg == msg) return NULL;
if (agent->msg) if (agent->msg)
edbus_message_unref(agent->msg); eldbus_message_unref(agent->msg);
agent->msg = edbus_message_ref((EDBus_Message *)msg); agent->msg = eldbus_message_ref((Eldbus_Message *)msg);
EINA_LIST_FOREACH(ctxt->instances, l, inst) EINA_LIST_FOREACH(ctxt->instances, l, inst)
econnman_popup_del(inst); econnman_popup_del(inst);
@ -408,18 +408,18 @@ _agent_request_input(const EDBus_Service_Interface *iface,
agent->dialog = _dialog_new(agent); agent->dialog = _dialog_new(agent);
EINA_SAFETY_ON_NULL_GOTO(agent->dialog, err); 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; 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; char *signature;
struct Connman_Field field = { NULL, NULL, NULL, NULL, NULL }; 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; goto err;
signature = edbus_message_iter_signature_get(var); signature = eldbus_message_iter_signature_get(var);
if (!signature) goto err; if (!signature) goto err;
if (!_parse_field(&field, var, signature)) if (!_parse_field(&field, var, signature))
@ -443,22 +443,22 @@ _agent_request_input(const EDBus_Service_Interface *iface,
return NULL; return NULL;
err: err:
edbus_message_unref((EDBus_Message *)msg); eldbus_message_unref((Eldbus_Message *)msg);
agent->msg = NULL; agent->msg = NULL;
WRN("Failed to parse msg"); WRN("Failed to parse msg");
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static EDBus_Message * static Eldbus_Message *
_agent_cancel(const EDBus_Service_Interface *iface, _agent_cancel(const Eldbus_Service_Interface *iface,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
E_Connman_Agent *agent; 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"); 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); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply);
if (agent->dialog) if (agent->dialog)
@ -467,48 +467,48 @@ _agent_cancel(const EDBus_Service_Interface *iface,
return reply; return reply;
} }
static const EDBus_Method methods[] = { static const Eldbus_Method methods[] = {
{ "Release", NULL, NULL, _agent_release, 0 }, { "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 _agent_report_error, 0
}, },
{ {
"RequestBrowser", EDBUS_ARGS({"o", "service"}, {"s", "url"}), NULL, "RequestBrowser", ELDBUS_ARGS({"o", "service"}, {"s", "url"}), NULL,
_agent_request_browser, 0 _agent_request_browser, 0
}, },
{ {
"RequestInput", EDBUS_ARGS({"o", "service"}, {"a{sv}", "fields"}), "RequestInput", ELDBUS_ARGS({"o", "service"}, {"a{sv}", "fields"}),
EDBUS_ARGS({"a{sv}", ""}), _agent_request_input, 0 ELDBUS_ARGS({"a{sv}", ""}), _agent_request_input, 0
}, },
{ "Cancel", NULL, NULL, _agent_cancel, 0 }, { "Cancel", NULL, NULL, _agent_cancel, 0 },
{ NULL, NULL, NULL, NULL, 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 AGENT_IFACE, methods, NULL, NULL, NULL, NULL
}; };
E_Connman_Agent * 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; E_Connman_Agent *agent;
agent = E_NEW(E_Connman_Agent, 1); agent = E_NEW(E_Connman_Agent, 1);
EINA_SAFETY_ON_NULL_RETURN_VAL(agent, NULL); 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) if (!iface)
{ {
ERR("Failed to create edbus interface"); ERR("Failed to create eldbus interface");
free(agent); free(agent);
return NULL; return NULL;
} }
edbus_service_object_data_set(iface, AGENT_KEY, agent); eldbus_service_object_data_set(iface, AGENT_KEY, agent);
agent->iface = iface; agent->iface = iface;
agent->conn = edbus_conn; agent->conn = eldbus_conn;
return agent; return agent;
} }
@ -517,6 +517,6 @@ void
econnman_agent_del(E_Connman_Agent *agent) econnman_agent_del(E_Connman_Agent *agent)
{ {
EINA_SAFETY_ON_NULL_RETURN(agent); EINA_SAFETY_ON_NULL_RETURN(agent);
edbus_service_object_unregister(agent->iface); eldbus_service_object_unregister(agent->iface);
free(agent); free(agent);
} }

250
src/modules/connman/e_connman.c
View File

@ -9,7 +9,7 @@
#define CONNMAN_CONNECTION_TIMEOUT 60 * MILLI_PER_SEC #define CONNMAN_CONNECTION_TIMEOUT 60 * MILLI_PER_SEC
static unsigned int init_count; static unsigned int init_count;
static EDBus_Connection *conn; static Eldbus_Connection *conn;
static struct Connman_Manager *connman_manager; static struct Connman_Manager *connman_manager;
static E_Connman_Agent *agent; static E_Connman_Agent *agent;
@ -30,16 +30,16 @@ static void _eina_str_array_clean(Eina_Array *array)
eina_array_clean(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) unsigned nelem)
{ {
EDBus_Message_Iter *itr_array; Eldbus_Message_Iter *itr_array;
Eina_Array *array; Eina_Array *array;
const char *s; const char *s;
EINA_SAFETY_ON_NULL_RETURN(value); EINA_SAFETY_ON_NULL_RETURN(value);
EINA_SAFETY_ON_NULL_RETURN(old); 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)); &itr_array));
array = *old; array = *old;
@ -51,7 +51,7 @@ static void _dbus_str_array_to_eina(EDBus_Message_Iter *value, Eina_Array **old,
else else
_eina_str_array_clean(array); _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)); eina_array_push(array, eina_stringshare_add(s));
DBG("Push %s", 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, static void _service_parse_prop_changed(struct Connman_Service *cs,
const char *prop_name, const char *prop_name,
EDBus_Message_Iter *value) Eldbus_Message_Iter *value)
{ {
DBG("service %p %s prop %s", cs, cs->path, prop_name); DBG("service %p %s prop %s", cs, cs->path, prop_name);
if (strcmp(prop_name, "State") == 0) if (strcmp(prop_name, "State") == 0)
{ {
const char *state; 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", "s",
&state)); &state));
cs->state = str_to_state(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) else if (strcmp(prop_name, "Name") == 0)
{ {
const char *name; 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", "s",
&name)); &name));
free(cs->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) else if (strcmp(prop_name, "Type") == 0)
{ {
const char *type; 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", "s",
&type)); &type));
cs->type = str_to_type(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) else if (strcmp(prop_name, "Strength") == 0)
{ {
uint8_t strength; 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", "y",
&strength)); &strength));
cs->strength = 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, static void _service_prop_dict_changed(struct Connman_Service *cs,
EDBus_Message_Iter *props) Eldbus_Message_Iter *props)
{ {
EDBus_Message_Iter *dict; Eldbus_Message_Iter *dict;
while (edbus_message_iter_get_and_next(props, 'e', &dict)) while (eldbus_message_iter_get_and_next(props, 'e', &dict))
{ {
char *name; 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; continue;
_service_parse_prop_changed(cs, name, var); _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; struct Connman_Service *cs = data;
EDBus_Message_Iter *var; Eldbus_Message_Iter *var;
const char *name; const char *name;
if (!edbus_message_arguments_get(msg, "sv", &name, &var)) if (!eldbus_message_arguments_get(msg, "sv", &name, &var))
return; return;
_service_parse_prop_changed(cs, name, var); _service_parse_prop_changed(cs, name, var);
@ -233,18 +233,18 @@ struct connection_data {
static void _service_free(struct Connman_Service *cs) static void _service_free(struct Connman_Service *cs)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
if (!cs) if (!cs)
return; return;
if (cs->pending.connect) if (cs->pending.connect)
{ {
edbus_pending_cancel(cs->pending.connect); eldbus_pending_cancel(cs->pending.connect);
free(cs->pending.data); free(cs->pending.data);
} }
if (cs->pending.disconnect) if (cs->pending.disconnect)
{ {
edbus_pending_cancel(cs->pending.disconnect); eldbus_pending_cancel(cs->pending.disconnect);
free(cs->pending.data); free(cs->pending.data);
} }
@ -252,17 +252,17 @@ static void _service_free(struct Connman_Service *cs)
_eina_str_array_clean(cs->security); _eina_str_array_clean(cs->security);
eina_array_free(cs->security); eina_array_free(cs->security);
eina_stringshare_del(cs->path); eina_stringshare_del(cs->path);
obj = edbus_proxy_object_get(cs->service_iface); obj = eldbus_proxy_object_get(cs->service_iface);
edbus_proxy_unref(cs->service_iface); eldbus_proxy_unref(cs->service_iface);
edbus_object_unref(obj); eldbus_object_unref(obj);
free(cs); 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; struct Connman_Service *cs;
EDBus_Object *obj; Eldbus_Object *obj;
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL); 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); cs->path = eina_stringshare_add(path);
obj = edbus_object_get(conn, CONNMAN_BUS_NAME, path); obj = eldbus_object_get(conn, CONNMAN_BUS_NAME, path);
cs->service_iface = edbus_proxy_get(obj, CONNMAN_SERVICE_IFACE); cs->service_iface = eldbus_proxy_get(obj, CONNMAN_SERVICE_IFACE);
edbus_proxy_signal_handler_add(cs->service_iface, "PropertyChanged", eldbus_proxy_signal_handler_add(cs->service_iface, "PropertyChanged",
_service_prop_changed, cs); _service_prop_changed, cs);
_service_prop_dict_changed(cs, props); _service_prop_dict_changed(cs, props);
return cs; return cs;
} }
static void _service_connection_cb(void *data, const EDBus_Message *msg, static void _service_connection_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
struct connection_data *cd = data; struct connection_data *cd = data;
if (cd->cb) if (cd->cb)
{ {
const char *s = NULL; const char *s = NULL;
edbus_message_error_get(msg, NULL, &s); eldbus_message_error_get(msg, NULL, &s);
cd->cb(cd->user_data, s); cd->cb(cd->user_data, s);
} }
@ -320,7 +320,7 @@ bool econnman_service_connect(struct Connman_Service *cs,
cd->cb = cb; cd->cb = cb;
cd->user_data = data; 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, _service_connection_cb, cd,
CONNMAN_CONNECTION_TIMEOUT, ""); CONNMAN_CONNECTION_TIMEOUT, "");
return true; return true;
@ -350,7 +350,7 @@ bool econnman_service_disconnect(struct Connman_Service *cs,
cd->cb = cb; cd->cb = cb;
cd->user_data = data; 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, _service_connection_cb, cd,
-1, ""); -1, "");
return true; 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, static void _manager_services_remove(struct Connman_Manager *cm,
EDBus_Message_Iter *array) Eldbus_Message_Iter *array)
{ {
const char *path; 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; struct Connman_Service *cs;
cs = econnman_manager_find_service(cm, path); 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; struct Connman_Manager *cm = data;
EDBus_Message_Iter *changed, *removed, *s; Eldbus_Message_Iter *changed, *removed, *s;
Eina_Inlist *tmp = NULL; Eina_Inlist *tmp = NULL;
if (cm->pending.get_services) if (cm->pending.get_services)
return; 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"); ERR("Error getting arguments");
return; return;
@ -423,13 +423,13 @@ static void _manager_services_changed(void *data, const EDBus_Message *msg)
_manager_services_remove(cm, removed); _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; struct Connman_Service *cs;
const char *path; 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; continue;
cs = econnman_manager_find_service(cm, path); 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); econnman_mod_services_changed(cm);
} }
static void _manager_get_services_cb(void *data, const EDBus_Message *msg, static void _manager_get_services_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
struct Connman_Manager *cm = data; struct Connman_Manager *cm = data;
EDBus_Message_Iter *array, *s; Eldbus_Message_Iter *array, *s;
const char *name, *text; const char *name, *text;
cm->pending.get_services = NULL; 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); ERR("Could not get services. %s: %s", name, text);
return; return;
} }
DBG("cm->services=%p", cm->services); 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"); ERR("Error getting array");
return; 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; struct Connman_Service *cs;
const char *path; 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; continue;
cs = _service_new(path, inner_array); 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, static bool _manager_parse_prop_changed(struct Connman_Manager *cm,
const char *name, const char *name,
EDBus_Message_Iter *value) Eldbus_Message_Iter *value)
{ {
if (strcmp(name, "State") == 0) if (strcmp(name, "State") == 0)
{ {
const char *state; const char *state;
if (!edbus_message_iter_arguments_get(value, "s", &state)) if (!eldbus_message_iter_arguments_get(value, "s", &state))
return false; return false;
DBG("New state: %s", state); DBG("New state: %s", state);
cm->state = str_to_state(state); cm->state = str_to_state(state);
} }
else if (strcmp(name, "OfflineMode") == 0) 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; return false;
} }
else else
@ -518,13 +518,13 @@ static bool _manager_parse_prop_changed(struct Connman_Manager *cm,
} }
static void 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; struct Connman_Manager *cm = data;
EDBus_Message_Iter *var; Eldbus_Message_Iter *var;
const char *name; 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); ERR("Could not parse message %p", msg);
return; return;
@ -533,31 +533,31 @@ _manager_prop_changed(void *data, const EDBus_Message *msg)
_manager_parse_prop_changed(cm, name, var); _manager_parse_prop_changed(cm, name, var);
} }
static void _manager_get_prop_cb(void *data, const EDBus_Message *msg, static void _manager_get_prop_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
struct Connman_Manager *cm = data; struct Connman_Manager *cm = data;
EDBus_Message_Iter *array, *dict; Eldbus_Message_Iter *array, *dict;
const char *name, *text; 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); ERR("Could not get properties. %s: %s", name, text);
return; return;
} }
if (!edbus_message_arguments_get(msg, "a{sv}", &array)) if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
return; return;
} }
while (edbus_message_iter_get_and_next(array, 'e', &dict)) while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{ {
const char *key; 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; continue;
_manager_parse_prop_changed(cm, key, var); _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, static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm,
const char *name, const char *name,
EDBus_Message_Iter *value) Eldbus_Message_Iter *value)
{ {
if (!strcmp(name, "Powered")) 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 else
return false; return false;
@ -576,13 +576,13 @@ static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm,
return true; 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; struct Connman_Manager *cm = data;
EDBus_Message_Iter *var; Eldbus_Message_Iter *var;
const char *name; 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); ERR("Could not parse message %p", msg);
return; 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); _manager_parse_wifi_prop_changed(cm, name, var);
} }
static void _manager_get_wifi_prop_cb(void *data, const EDBus_Message *msg, static void _manager_get_wifi_prop_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
struct Connman_Manager *cm = data; struct Connman_Manager *cm = data;
EDBus_Message_Iter *array, *dict; Eldbus_Message_Iter *array, *dict;
const char *name, *message; const char *name, *message;
cm->pending.get_wifi_properties = NULL; 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); ERR("Could not get properties. %s: %s", name, message);
return; return;
} }
if (!edbus_message_arguments_get(msg, "a{sv}", &array)) if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
return; 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; const char *key;
if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &var))
continue; continue;
_manager_parse_wifi_prop_changed(cm, key, var); _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 static void
_manager_agent_unregister(struct Connman_Manager *cm) _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); AGENT_PATH);
} }
static void static void
_manager_agent_register_cb(void *data, const EDBus_Message *msg, _manager_agent_register_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
const char *name, *text; 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); WRN("Could not register agent. %s: %s", name, text);
return; return;
@ -651,13 +651,13 @@ _manager_agent_register(struct Connman_Manager *cm)
if (!cm) if (!cm)
return; return;
edbus_proxy_call(cm->manager_iface, "RegisterAgent", eldbus_proxy_call(cm->manager_iface, "RegisterAgent",
_manager_agent_register_cb, NULL, -1, "o", AGENT_PATH); _manager_agent_register_cb, NULL, -1, "o", AGENT_PATH);
} }
static void _manager_free(struct Connman_Manager *cm) static void _manager_free(struct Connman_Manager *cm)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
if (!cm) if (!cm)
return; return;
@ -670,61 +670,61 @@ static void _manager_free(struct Connman_Manager *cm)
} }
if (cm->pending.get_services) 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) 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) if (cm->pending.set_powered)
edbus_pending_cancel(cm->pending.set_powered); eldbus_pending_cancel(cm->pending.set_powered);
eina_stringshare_del(cm->path); eina_stringshare_del(cm->path);
obj = edbus_proxy_object_get(cm->manager_iface); obj = eldbus_proxy_object_get(cm->manager_iface);
edbus_proxy_unref(cm->manager_iface); eldbus_proxy_unref(cm->manager_iface);
edbus_object_unref(obj); eldbus_object_unref(obj);
obj = edbus_proxy_object_get(cm->technology_iface); obj = eldbus_proxy_object_get(cm->technology_iface);
edbus_proxy_unref(cm->technology_iface); eldbus_proxy_unref(cm->technology_iface);
edbus_object_unref(obj); eldbus_object_unref(obj);
free(cm); free(cm);
} }
static void _manager_powered_cb(void *data, const EDBus_Message *msg, static void _manager_powered_cb(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending) Eldbus_Pending *pending)
{ {
EDBus_Pending *p; Eldbus_Pending *p;
struct Connman_Manager *cm = data; struct Connman_Manager *cm = data;
const char *error_name, *error_msg; const char *error_name, *error_msg;
cm->pending.set_powered = NULL; 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); ERR("Error: %s %s", error_name, error_msg);
return; return;
} }
if (cm->pending.get_wifi_properties) if (cm->pending.get_wifi_properties)
edbus_pending_cancel(cm->pending.get_wifi_properties); eldbus_pending_cancel(cm->pending.get_wifi_properties);
p = edbus_proxy_call(cm->technology_iface, "GetProperties", p = eldbus_proxy_call(cm->technology_iface, "GetProperties",
_manager_get_wifi_prop_cb, cm, -1, ""); _manager_get_wifi_prop_cb, cm, -1, "");
cm->pending.get_wifi_properties = p; cm->pending.get_wifi_properties = p;
} }
void econnman_powered_set(struct Connman_Manager *cm, Eina_Bool powered) void econnman_powered_set(struct Connman_Manager *cm, Eina_Bool powered)
{ {
EDBus_Message_Iter *main_iter, *var; Eldbus_Message_Iter *main_iter, *var;
EDBus_Message *msg; Eldbus_Message *msg;
if (cm->pending.set_powered) 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"); msg = eldbus_proxy_method_call_new(cm->technology_iface, "SetProperty");
main_iter = edbus_message_iter_get(msg); main_iter = eldbus_message_iter_get(msg);
edbus_message_iter_basic_append(main_iter, 's', "Powered"); eldbus_message_iter_basic_append(main_iter, 's', "Powered");
var = edbus_message_iter_container_new(main_iter, 'v', "b"); var = eldbus_message_iter_container_new(main_iter, 'v', "b");
edbus_message_iter_basic_append(var, 'b', powered); eldbus_message_iter_basic_append(var, 'b', powered);
edbus_message_iter_container_close(main_iter, var); 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); _manager_powered_cb, cm, -1);
} }
@ -732,25 +732,25 @@ static struct Connman_Manager *_manager_new(void)
{ {
const char *path = "/"; const char *path = "/";
struct Connman_Manager *cm; struct Connman_Manager *cm;
EDBus_Object *obj; Eldbus_Object *obj;
cm = calloc(1, sizeof(*cm)); cm = calloc(1, sizeof(*cm));
EINA_SAFETY_ON_NULL_RETURN_VAL(cm, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(cm, NULL);
obj = edbus_object_get(conn, CONNMAN_BUS_NAME, "/"); obj = eldbus_object_get(conn, CONNMAN_BUS_NAME, "/");
cm->manager_iface = edbus_proxy_get(obj, CONNMAN_MANAGER_IFACE); cm->manager_iface = eldbus_proxy_get(obj, CONNMAN_MANAGER_IFACE);
obj = edbus_object_get(conn, CONNMAN_BUS_NAME, obj = eldbus_object_get(conn, CONNMAN_BUS_NAME,
"/net/connman/technology/wifi"); "/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); 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); _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); _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); _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 * after ServicesChanged above. So we only add the handler later, in a per
* service manner. * service manner.
*/ */
cm->pending.get_services = edbus_proxy_call(cm->manager_iface, cm->pending.get_services = eldbus_proxy_call(cm->manager_iface,
"GetServices", "GetServices",
_manager_get_services_cb, cm, _manager_get_services_cb, cm,
-1, ""); -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, ""); -1, "");
cm->pending.get_wifi_properties = edbus_proxy_call(cm->technology_iface, cm->pending.get_wifi_properties = eldbus_proxy_call(cm->technology_iface,
"GetProperties", "GetProperties",
_manager_get_wifi_prop_cb, _manager_get_wifi_prop_cb,
cm, -1, ""); 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. * - E_CONNMAN_EVENT_MANAGER_OUT: issued when connman connection is lost.
*/ */
unsigned int unsigned int
e_connman_system_init(EDBus_Connection *edbus_conn) e_connman_system_init(Eldbus_Connection *eldbus_conn)
{ {
init_count++; 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_IN = ecore_event_type_new();
E_CONNMAN_EVENT_MANAGER_OUT = ecore_event_type_new(); E_CONNMAN_EVENT_MANAGER_OUT = ecore_event_type_new();
conn = edbus_conn; conn = eldbus_conn;
edbus_name_owner_changed_callback_add(conn, CONNMAN_BUS_NAME, eldbus_name_owner_changed_callback_add(conn, CONNMAN_BUS_NAME,
_e_connman_system_name_owner_changed, _e_connman_system_name_owner_changed,
NULL, EINA_TRUE); NULL, EINA_TRUE);
agent = econnman_agent_new(edbus_conn); agent = econnman_agent_new(eldbus_conn);
return init_count; return init_count;
} }
@ -849,14 +849,14 @@ e_connman_system_shutdown(void)
if (init_count > 0) if (init_count > 0)
return init_count; 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, _e_connman_system_name_owner_changed,
NULL); NULL);
_e_connman_system_name_owner_exit(); _e_connman_system_name_owner_exit();
if (agent) if (agent)
econnman_agent_del(agent); econnman_agent_del(agent);
if (conn) if (conn)
edbus_connection_unref(conn); eldbus_connection_unref(conn);
agent = NULL; agent = NULL;
conn = NULL; conn = NULL;

10
src/modules/connman/e_mod_main.c
View File

@ -606,7 +606,7 @@ EAPI void *
e_modapi_init(E_Module *m) e_modapi_init(E_Module *m)
{ {
E_Connman_Module_Context *ctxt; E_Connman_Module_Context *ctxt;
EDBus_Connection *c; Eldbus_Connection *c;
if (_e_connman_log_dom < 0) if (_e_connman_log_dom < 0)
{ {
@ -622,8 +622,8 @@ e_modapi_init(E_Module *m)
ctxt = E_NEW(E_Connman_Module_Context, 1); ctxt = E_NEW(E_Connman_Module_Context, 1);
if (!ctxt) if (!ctxt)
goto error_connman_context; goto error_connman_context;
edbus_init(); eldbus_init();
c = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); c = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
if (!c) if (!c)
goto error_dbus_bus_get; goto error_dbus_bus_get;
if (!e_connman_system_init(c)) if (!e_connman_system_init(c))
@ -638,7 +638,7 @@ e_modapi_init(E_Module *m)
return ctxt; return ctxt;
error_connman_system_init: error_connman_system_init:
edbus_connection_unref(c); eldbus_connection_unref(c);
error_dbus_bus_get: error_dbus_bus_get:
E_FREE(ctxt); E_FREE(ctxt);
error_connman_context: error_connman_context:
@ -670,7 +670,7 @@ e_modapi_shutdown(E_Module *m)
return 0; return 0;
e_connman_system_shutdown(); e_connman_system_shutdown();
edbus_shutdown(); eldbus_shutdown();
_econnman_instances_free(ctxt); _econnman_instances_free(ctxt);
_econnman_configure_registry_unregister(); _econnman_configure_registry_unregister();

2
src/modules/connman/e_mod_main.h
View File

@ -60,7 +60,7 @@ const char *e_connman_theme_path(void);
E_Config_Dialog *e_connman_config_dialog_new(E_Container *con, E_Config_Dialog *e_connman_config_dialog_new(E_Container *con,
E_Connman_Module_Context *ctxt); 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); void econnman_agent_del(E_Connman_Agent *agent);
/** /**

62
src/modules/fileman/e_mod_dbus.c
View File

@ -8,36 +8,36 @@ static const char E_FILEMAN_PATH[] = "/org/enlightenment/FileManager";
typedef struct _E_Fileman_DBus_Daemon E_Fileman_DBus_Daemon; typedef struct _E_Fileman_DBus_Daemon E_Fileman_DBus_Daemon;
struct _E_Fileman_DBus_Daemon struct _E_Fileman_DBus_Daemon
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
}; };
static EDBus_Message * _e_fileman_dbus_daemon_open_directory_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 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_file_cb(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
static EDBus_Message * static Eldbus_Message *
_e_fileman_dbus_daemon_error(const EDBus_Message *msg, _e_fileman_dbus_daemon_error(const Eldbus_Message *msg,
const char *error_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[] = { static const Eldbus_Method methods[] = {
{ "OpenDirectory", EDBUS_ARGS({"s", "directory"}), NULL, { "OpenDirectory", ELDBUS_ARGS({"s", "directory"}), NULL,
_e_fileman_dbus_daemon_open_directory_cb }, _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 }, _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 E_FILEMAN_INTERFACE, methods
}; };
static void static void
_e_fileman_dbus_daemon_object_init(E_Fileman_DBus_Daemon *d) _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) if (!d->iface)
{ {
fprintf(stderr, "ERROR: cannot add object to %s\n", E_FILEMAN_PATH); 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) _e_fileman_dbus_daemon_free(E_Fileman_DBus_Daemon *d)
{ {
if (d->iface) if (d->iface)
edbus_service_object_unregister(d->iface); eldbus_service_object_unregister(d->iface);
if (d->conn) if (d->conn)
edbus_connection_unref(d->conn); eldbus_connection_unref(d->conn);
free(d); free(d);
} }
static EDBus_Message * static Eldbus_Message *
_e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_fileman_dbus_daemon_open_directory_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
const char *directory = NULL, *p; const char *directory = NULL, *p;
char *dev, *to_free = NULL; char *dev, *to_free = NULL;
E_Zone *zone; 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"); 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')) 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); e_fwin_new(zone->container, dev, directory);
free(dev); free(dev);
free(to_free); free(to_free);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static Eina_Bool static Eina_Bool
@ -150,19 +150,19 @@ _mime_shell_script_check(const char *mime)
return EINA_FALSE; return EINA_FALSE;
} }
static EDBus_Message* static Eldbus_Message*
_e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface __UNUSED__, _e_fileman_dbus_daemon_open_file_cb(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
Eina_List *handlers; Eina_List *handlers;
const char *param_file = NULL, *mime, *errmsg = "unknow error"; const char *param_file = NULL, *mime, *errmsg = "unknow error";
char *real_file, *to_free = NULL; char *real_file, *to_free = NULL;
E_Zone *zone; E_Zone *zone;
if (!edbus_message_arguments_get(msg, "s", &param_file)) if (!eldbus_message_arguments_get(msg, "s", &param_file))
{ {
fprintf(stderr, "ERROR: getting arguments of OpenFile call.\n"); 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')) 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: end:
free(real_file); free(real_file);
free(to_free); free(to_free);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
error: error:
free(real_file); free(real_file);
@ -290,13 +290,13 @@ _e_fileman_dbus_daemon_new(void)
return NULL; return NULL;
} }
d->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); d->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
if (!d->conn) if (!d->conn)
goto error; goto error;
_e_fileman_dbus_daemon_object_init(d); _e_fileman_dbus_daemon_object_init(d);
edbus_name_request(d->conn, E_FILEMAN_BUS_NAME, eldbus_name_request(d->conn, E_FILEMAN_BUS_NAME,
EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL); ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL);
return d; return d;
error: error:
@ -313,7 +313,7 @@ e_fileman_dbus_init(void)
if (_daemon) if (_daemon)
return; return;
edbus_init(); eldbus_init();
_daemon = _e_fileman_dbus_daemon_new(); _daemon = _e_fileman_dbus_daemon_new();
} }
@ -325,6 +325,6 @@ e_fileman_dbus_shutdown(void)
_e_fileman_dbus_daemon_free(_daemon); _e_fileman_dbus_daemon_free(_daemon);
_daemon = NULL; _daemon = NULL;
edbus_shutdown(); eldbus_shutdown();
} }

48
src/modules/mixer/sys_pulse.c
View File

@ -18,8 +18,8 @@ static Ecore_Poller *pulse_poller = NULL;
static Eina_Hash *queue_states = NULL; static Eina_Hash *queue_states = NULL;
static const char *_name = NULL; static const char *_name = NULL;
static EDBus_Connection *dbus = NULL; static Eldbus_Connection *dbus = NULL;
static EDBus_Signal_Handler *dbus_handler = NULL; static Eldbus_Signal_Handler *dbus_handler = NULL;
static Ecore_Timer *disc_timer = NULL; static Ecore_Timer *disc_timer = NULL;
static unsigned int disc_count = 0; static unsigned int disc_count = 0;
@ -38,10 +38,10 @@ _pulse_poller_cb(void *d __UNUSED__)
} }
static void 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; 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)) if (!strcmp(name, PULSE_BUS))
e_mixer_pulse_init(); e_mixer_pulse_init();
@ -49,32 +49,32 @@ _dbus_poll(void *data EINA_UNUSED, const EDBus_Message *msg)
if (dbus_handler) if (dbus_handler)
{ {
edbus_signal_handler_del(dbus_handler); eldbus_signal_handler_del(dbus_handler);
dbus_handler = NULL; dbus_handler = NULL;
} }
if (dbus) if (dbus)
{ {
edbus_connection_unref(dbus); eldbus_connection_unref(dbus);
dbus = NULL; dbus = NULL;
edbus_shutdown(); eldbus_shutdown();
} }
} }
static void 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) if (dbus_handler)
{ {
edbus_signal_handler_del(dbus_handler); eldbus_signal_handler_del(dbus_handler);
dbus_handler = NULL; dbus_handler = NULL;
} }
if (dbus) if (dbus)
{ {
edbus_connection_unref(dbus); eldbus_connection_unref(dbus);
dbus = NULL; dbus = NULL;
edbus_shutdown(); eldbus_shutdown();
} }
e_mod_mixer_pulse_ready(EINA_FALSE); e_mod_mixer_pulse_ready(EINA_FALSE);
return; return;
@ -342,15 +342,15 @@ e_mixer_pulse_init(void)
if (dbus) goto error; if (dbus) goto error;
if ((!conn) || (!pulse_connect(conn))) if ((!conn) || (!pulse_connect(conn)))
{ {
EDBus_Message *msg; Eldbus_Message *msg;
double interval; double interval;
edbus_init(); eldbus_init();
dbus = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); dbus = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
if (!dbus) if (!dbus)
{ {
edbus_shutdown(); eldbus_shutdown();
return EINA_FALSE; return EINA_FALSE;
} }
@ -362,13 +362,13 @@ e_mixer_pulse_init(void)
_pulse_poller_cb, NULL); _pulse_poller_cb, NULL);
} }
if (!dbus_handler) if (!dbus_handler)
dbus_handler = edbus_signal_handler_add(dbus, EDBUS_FDO_BUS, dbus_handler = eldbus_signal_handler_add(dbus, ELDBUS_FDO_BUS,
EDBUS_FDO_PATH, ELDBUS_FDO_PATH,
EDBUS_FDO_INTERFACE, ELDBUS_FDO_INTERFACE,
"NameOwnerChanged", _dbus_poll, NULL); "NameOwnerChanged", _dbus_poll, NULL);
msg = edbus_message_method_call_new(PULSE_BUS, PULSE_PATH, PULSE_INTERFACE, "suuuuuup"); msg = eldbus_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 */ eldbus_connection_send(dbus, msg, _dbus_test, NULL, -1); /* test for not running pulse */
pulse_free(conn); pulse_free(conn);
conn = NULL; conn = NULL;
pulse_shutdown(); pulse_shutdown();
@ -414,14 +414,14 @@ e_mixer_pulse_shutdown(void)
queue_states = NULL; queue_states = NULL;
if (dbus_handler) if (dbus_handler)
{ {
edbus_signal_handler_del(dbus_handler); eldbus_signal_handler_del(dbus_handler);
dbus_handler = NULL; dbus_handler = NULL;
} }
if (dbus) if (dbus)
{ {
edbus_connection_unref(dbus); eldbus_connection_unref(dbus);
dbus = NULL; dbus = NULL;
edbus_shutdown(); eldbus_shutdown();
} }
pulse_shutdown(); pulse_shutdown();
if (_name) eina_stringshare_del(_name); if (_name) eina_stringshare_del(_name);

4
src/modules/msgbus/e_mod_main.c
View File

@ -25,11 +25,11 @@ e_modapi_init(E_Module *m)
EAPI int EAPI int
e_modapi_shutdown(E_Module *m __UNUSED__) e_modapi_shutdown(E_Module *m __UNUSED__)
{ {
EDBus_Service_Interface* iface; Eldbus_Service_Interface* iface;
Eina_Array_Iterator iter; Eina_Array_Iterator iter;
size_t i; size_t i;
EINA_ARRAY_ITER_NEXT(ifaces, i, iface, iter) EINA_ARRAY_ITER_NEXT(ifaces, i, iface, iter)
edbus_service_interface_unregister(iface); eldbus_service_interface_unregister(iface);
eina_array_free(ifaces); eina_array_free(ifaces);
ifaces = NULL; ifaces = NULL;
return 1; return 1;

20
src/modules/msgbus/msgbus_audit.c
View File

@ -10,35 +10,35 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
static EDBus_Message * static Eldbus_Message *
cb_audit_timer_dump(const EDBus_Service_Interface *iface __UNUSED__, cb_audit_timer_dump(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
char *tmp; char *tmp;
tmp = ecore_timer_dump(); tmp = ecore_timer_dump();
if (!tmp) if (!tmp)
edbus_message_arguments_append(reply, "s", eldbus_message_arguments_append(reply, "s",
"Not enable, recompile Ecore with ecore_timer_dump."); "Not enable, recompile Ecore with ecore_timer_dump.");
else else
edbus_message_arguments_append(reply, "s", tmp); eldbus_message_arguments_append(reply, "s", tmp);
return reply; return reply;
} }
static const EDBus_Method methods[] = { static const Eldbus_Method methods[] = {
{ "Timers", NULL, EDBUS_ARGS({"s", ""}), cb_audit_timer_dump }, { "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 "org.enlightenment.wm.Audit", methods
}; };
void msgbus_audit_init(Eina_Array *ifaces) void msgbus_audit_init(Eina_Array *ifaces)
{ {
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
if (_log_dom == -1) if (_log_dom == -1)
{ {

112
src/modules/msgbus/msgbus_desktop.c
View File

@ -10,12 +10,12 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
static EDBus_Message * static Eldbus_Message *
cb_virtual_desktops(const EDBus_Service_Interface *iface __UNUSED__, cb_virtual_desktops(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
edbus_message_arguments_append(reply, "ii", e_config->zone_desks_x_count, eldbus_message_arguments_append(reply, "ii", e_config->zone_desks_x_count,
e_config->zone_desks_y_count); e_config->zone_desks_y_count);
DBG("GetVirtualCount: %d %d", DBG("GetVirtualCount: %d %d",
e_config->zone_desks_x_count, e_config->zone_desks_y_count); 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; return reply;
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_show(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_show(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
int x, y; int x, y;
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
E_Zone *zone; 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"); ERR("could not get Show arguments");
return reply; return reply;
@ -44,16 +44,16 @@ cb_desktop_show(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_show_by_name(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_show_by_name(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) 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; const char *name;
E_Zone *zone; E_Zone *zone;
unsigned int i, count; 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"); ERR("could not get Show arguments");
return reply; return reply;
@ -76,35 +76,35 @@ cb_desktop_show_by_name(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_lock(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_lock(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
DBG("desklock requested"); DBG("desklock requested");
e_desklock_show(EINA_FALSE); e_desklock_show(EINA_FALSE);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_unlock(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_unlock(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
DBG("deskunlock requested"); DBG("deskunlock requested");
e_desklock_hide(); e_desklock_hide();
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_bgadd(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_bgadd(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
int container, zone, desk_x, desk_y; int container, zone, desk_x, desk_y;
const char *path; 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)) &desk_y, &path))
{ {
ERR("could not get Add arguments"); ERR("could not get Add arguments");
@ -120,14 +120,14 @@ cb_desktop_bgadd(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_bgdel(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_bgdel(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
int container, zone, desk_x, desk_y; 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)) &desk_y))
{ {
ERR("could not get Del arguments"); ERR("could not get Del arguments");
@ -143,28 +143,28 @@ cb_desktop_bgdel(const EDBus_Service_Interface *iface __UNUSED__,
return reply; return reply;
} }
static EDBus_Message * static Eldbus_Message *
cb_desktop_bglist(const EDBus_Service_Interface *iface __UNUSED__, cb_desktop_bglist(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
Eina_List *list; Eina_List *list;
E_Config_Desktop_Background *bg; E_Config_Desktop_Background *bg;
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
EDBus_Message_Iter *main_iter, *array; Eldbus_Message_Iter *main_iter, *array;
if (!reply) if (!reply)
return NULL; return NULL;
main_iter = edbus_message_iter_get(reply); main_iter = eldbus_message_iter_get(reply);
if (!main_iter) if (!main_iter)
return reply; 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; return reply;
EINA_LIST_FOREACH(e_config->desktop_backgrounds, list, bg) EINA_LIST_FOREACH(e_config->desktop_backgrounds, list, bg)
{ {
EDBus_Message_Iter *s; Eldbus_Message_Iter *s;
if (!bg || !bg->file) 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", DBG("Background container=%d zone=%d pos=%d,%d path=%s",
bg->container, bg->zone, bg->desk_x, bg->desk_y, bg->file); 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; 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); 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; return reply;
} }
static const EDBus_Method desktop_methods[] = { static const Eldbus_Method desktop_methods[] = {
{ "GetVirtualCount", NULL, EDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}), { "GetVirtualCount", NULL, ELDBUS_ARGS({"i", "desk_x"}, {"i", "desk_y"}),
cb_virtual_desktops }, 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 }, cb_desktop_show },
{ "ShowByName", EDBUS_ARGS({"s", "desk_name"}), NULL, { "ShowByName", ELDBUS_ARGS({"s", "desk_name"}), NULL,
cb_desktop_show_by_name }, cb_desktop_show_by_name },
{ "Lock", NULL, NULL, cb_desktop_lock }, { "Lock", NULL, NULL, cb_desktop_lock },
{ "Unlock", NULL, NULL, cb_desktop_unlock }, { "Unlock", NULL, NULL, cb_desktop_unlock },
{ } { }
}; };
static const EDBus_Method background_methods[] = { static const Eldbus_Method background_methods[] = {
{ "Add", { "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 }, 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 }, 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 "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 "org.enlightenment.wm.Desktop.Background", background_methods
}; };
void msgbus_desktop_init(Eina_Array *ifaces) void msgbus_desktop_init(Eina_Array *ifaces)
{ {
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
if (_log_dom == -1) if (_log_dom == -1)
{ {

26
src/modules/msgbus/msgbus_lang.c
View File

@ -10,45 +10,45 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
static EDBus_Message * static Eldbus_Message *
cb_langs(const EDBus_Service_Interface *iface __UNUSED__, cb_langs(const Eldbus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg) const Eldbus_Message *msg)
{ {
EDBus_Message *reply = edbus_message_method_return_new(msg); Eldbus_Message *reply = eldbus_message_method_return_new(msg);
EDBus_Message_Iter *main_iter, *array; Eldbus_Message_Iter *main_iter, *array;
const Eina_List *l; const Eina_List *l;
const char *str; const char *str;
if (!reply) return NULL; if (!reply) return NULL;
main_iter = edbus_message_iter_get(reply); main_iter = eldbus_message_iter_get(reply);
edbus_message_iter_arguments_append(main_iter, "as", &array); eldbus_message_iter_arguments_append(main_iter, "as", &array);
if (!array) return reply; if (!array) return reply;
EINA_LIST_FOREACH(e_intl_language_list(), l, str) EINA_LIST_FOREACH(e_intl_language_list(), l, str)
{ {
DBG("language: %s", 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; 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 } { 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 "org.enlightenment.wm.Language", methods, NULL, NULL, NULL, NULL
}; };
void msgbus_lang_init(Eina_Array *ifaces) void msgbus_lang_init(Eina_Array *ifaces)
{ {
EDBus_Service_Interface *iface; Eldbus_Service_Interface *iface;
if (_log_dom == -1) if (_log_dom == -1)
{ {
_log_dom = eina_log_domain_register("msgbus_lang", EINA_COLOR_BLUE); _log_dom = eina_log_domain_register("msgbus_lang", EINA_COLOR_BLUE);

16
src/modules/music-control/e_mod_main.c
View File

@ -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 }; EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, _e_music_control_Name };
static void 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; 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 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; E_Music_Control_Module_Context *ctxt = data;
if (!strcmp(event->name, "PlaybackStatus")) if (!strcmp(event->name, "PlaybackStatus"))
@ -248,14 +248,14 @@ prop_changed(void *data, EDBus_Proxy *proxy, void *event_info)
Eina_Bool Eina_Bool
music_control_dbus_init(E_Music_Control_Module_Context *ctxt, const char *bus) music_control_dbus_init(E_Music_Control_Module_Context *ctxt, const char *bus)
{ {
edbus_init(); eldbus_init();
ctxt->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); ctxt->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
EINA_SAFETY_ON_NULL_RETURN_VAL(ctxt->conn, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(ctxt->conn, EINA_FALSE);
ctxt->mrpis2 = mpris_media_player2_proxy_get(ctxt->conn, bus, NULL); ctxt->mrpis2 = mpris_media_player2_proxy_get(ctxt->conn, bus, NULL);
ctxt->mpris2_player = media_player2_player_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); 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); prop_changed, ctxt);
return EINA_TRUE; return EINA_TRUE;
} }
@ -310,8 +310,8 @@ e_modapi_shutdown(E_Module *m)
media_player2_player_proxy_unref(ctxt->mpris2_player); media_player2_player_proxy_unref(ctxt->mpris2_player);
mpris_media_player2_proxy_unref(ctxt->mrpis2); mpris_media_player2_proxy_unref(ctxt->mrpis2);
edbus_connection_unref(ctxt->conn); eldbus_connection_unref(ctxt->conn);
edbus_shutdown(); eldbus_shutdown();
e_gadcon_provider_unregister(&_gc_class); e_gadcon_provider_unregister(&_gc_class);

923
src/modules/music-control/gen/edbus_media_player2_player.c
View File

@ -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;
}

47
src/modules/music-control/gen/edbus_media_player2_player.h
View File

@ -1,47 +0,0 @@
#ifndef EDBUS_MEDIA_PLAYER2_PLAYER_H
#define EDBUS_MEDIA_PLAYER2_PLAYER_H
#include <Eina.h>
#include <Ecore.h>
#include <EDBus.h>
#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

350
src/modules/music-control/gen/edbus_mpris_media_player2.c
View File

@ -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;
}

22
src/modules/music-control/gen/edbus_mpris_media_player2.h
View File

@ -1,22 +0,0 @@
#ifndef EDBUS_MPRIS_MEDIA_PLAYER2_H
#define EDBUS_MPRIS_MEDIA_PLAYER2_H
#include <Eina.h>
#include <Ecore.h>
#include <EDBus.h>
#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

24
src/modules/music-control/gen/edbus_utils.h
View File

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

923
src/modules/music-control/gen/eldbus_media_player2_player.c Normal file
View File

@ -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;
}

47
src/modules/music-control/gen/eldbus_media_player2_player.h Normal file
View File

@ -0,0 +1,47 @@
#ifndef ELDBUS_MEDIA_PLAYER2_PLAYER_H
#define ELDBUS_MEDIA_PLAYER2_PLAYER_H
#include <Eina.h>
#include <Ecore.h>
#include <Eldbus.h>
#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

350
src/modules/music-control/gen/eldbus_mpris_media_player2.c Normal file
View File

@ -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;
}

22
src/modules/music-control/gen/eldbus_mpris_media_player2.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef ELDBUS_MPRIS_MEDIA_PLAYER2_H
#define ELDBUS_MPRIS_MEDIA_PLAYER2_H
#include <Eina.h>
#include <Ecore.h>
#include <Eldbus.h>
#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

24
src/modules/music-control/gen/eldbus_utils.h Normal file
View File

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

10
src/modules/music-control/private.h
View File

@ -2,8 +2,8 @@
#define MUSIC_CONTROL_PRIVATE_H #define MUSIC_CONTROL_PRIVATE_H
#include "e_mod_main.h" #include "e_mod_main.h"
#include "gen/edbus_media_player2_player.h" #include "gen/eldbus_media_player2_player.h"
#include "gen/edbus_mpris_media_player2.h" #include "gen/eldbus_mpris_media_player2.h"
static Ecore_Event_Handler *desklock_handler = NULL; static Ecore_Event_Handler *desklock_handler = NULL;
@ -16,10 +16,10 @@ typedef struct _Music_Control_Config
typedef struct _E_Music_Control_Module_Context typedef struct _E_Music_Control_Module_Context
{ {
Eina_List *instances; Eina_List *instances;
EDBus_Connection *conn; Eldbus_Connection *conn;
Eina_Bool playing:1; Eina_Bool playing:1;
EDBus_Proxy *mrpis2; Eldbus_Proxy *mrpis2;
EDBus_Proxy *mpris2_player; Eldbus_Proxy *mpris2_player;
E_Config_DD *conf_edd; E_Config_DD *conf_edd;
Music_Control_Config *config; Music_Control_Config *config;
Eina_Bool actions_set:1; Eina_Bool actions_set:1;

16
src/modules/systray/e_mod_notifier_host.c
View File

@ -20,8 +20,8 @@ static Context_Notifier_Host *ctx = NULL;
void void
systray_notifier_item_free(Notifier_Item *item) systray_notifier_item_free(Notifier_Item *item)
{ {
EDBus_Object *obj; Eldbus_Object *obj;
EDBus_Signal_Handler *sig; Eldbus_Signal_Handler *sig;
Instance_Notifier_Host *host_inst; Instance_Notifier_Host *host_inst;
EINA_INLIST_FOREACH(ctx->instances, host_inst) EINA_INLIST_FOREACH(ctx->instances, host_inst)
{ {
@ -56,10 +56,10 @@ systray_notifier_item_free(Notifier_Item *item)
if (item->title) if (item->title)
eina_stringshare_del(item->title); eina_stringshare_del(item->title);
EINA_LIST_FREE(item->signals, sig) EINA_LIST_FREE(item->signals, sig)
edbus_signal_handler_del(sig); eldbus_signal_handler_del(sig);
obj = edbus_proxy_object_get(item->proxy); obj = eldbus_proxy_object_get(item->proxy);
edbus_proxy_unref(item->proxy); eldbus_proxy_unref(item->proxy);
edbus_object_unref(obj); eldbus_object_unref(obj);
ctx->item_list = eina_inlist_remove(ctx->item_list, EINA_INLIST_GET(item)); ctx->item_list = eina_inlist_remove(ctx->item_list, EINA_INLIST_GET(item));
free(item); free(item);
} }
@ -334,9 +334,9 @@ systray_notifier_host_init(void)
void void
systray_notifier_host_shutdown(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); systray_notifier_dbus_shutdown(ctx);
free(ctx); free(ctx);
ctx = NULL; ctx = NULL;

160
src/modules/systray/e_mod_notifier_host_dbus.c
View File

@ -57,78 +57,78 @@ id_find(const char *s, const char *names[])
} }
static void 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; Notifier_Item *item = data;
if (!strcmp(key, "Category")) if (!strcmp(key, "Category"))
{ {
const char *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); item->category = id_find(category, Category_Names);
} }
else if (!strcmp(key, "IconName")) else if (!strcmp(key, "IconName"))
{ {
const char *name; 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); eina_stringshare_replace(&item->icon_name, name);
} }
else if (!strcmp(key, "AttentionIconName")) else if (!strcmp(key, "AttentionIconName"))
{ {
const char *name; 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); eina_stringshare_replace(&item->attention_icon_name, name);
} }
else if (!strcmp(key, "IconThemePath")) else if (!strcmp(key, "IconThemePath"))
{ {
const char *path; 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); eina_stringshare_replace(&item->icon_path, path);
} }
else if (!strcmp(key, "Menu")) else if (!strcmp(key, "Menu"))
{ {
const char *path; 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); eina_stringshare_replace(&item->menu_path, path);
} }
else if (!strcmp(key, "Status")) else if (!strcmp(key, "Status"))
{ {
const char *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); item->status = id_find(status, Status_Names);
} }
else if (!strcmp(key, "Id")) else if (!strcmp(key, "Id"))
{ {
const char *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); eina_stringshare_replace(&item->id, id);
} }
else if (!strcmp(key, "Title")) else if (!strcmp(key, "Title"))
{ {
const char *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); eina_stringshare_replace(&item->title, title);
} }
} }
static void static void
props_changed(void *data, const EDBus_Message *msg) props_changed(void *data, const Eldbus_Message *msg)
{ {
Notifier_Item *item = data; Notifier_Item *item = data;
const char *interface, *menu = item->menu_path; 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"); ERR("Error reading message");
return; 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) 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; item->dbus_item = NULL;
e_dbusmenu_unload(item->menu_data); e_dbusmenu_unload(item->menu_data);
item->menu_data = e_dbusmenu_load(conn, item->bus_id, item->menu_path, 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 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; const char *error, *error_name;
EDBus_Message_Iter *dict; Eldbus_Message_Iter *dict;
Notifier_Item *item = data; 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); ERR("%s %s", error, error_name);
return; return;
} }
if (!edbus_message_arguments_get(msg, "a{sv}", &dict)) if (!eldbus_message_arguments_get(msg, "a{sv}", &dict))
{ {
ERR("Error getting arguments."); ERR("Error getting arguments.");
return; 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) if (!item->menu_path)
ERR("Notifier item %s dont have menu path.", 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); 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); 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 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; 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); ERR("%s %s", error, error_msg);
return EINA_FALSE; return EINA_FALSE;
} }
if (!edbus_message_arguments_get(msg, "v", &var)) if (!eldbus_message_arguments_get(msg, "v", &var))
{ {
ERR("Error reading message."); ERR("Error reading message.");
return EINA_FALSE; return EINA_FALSE;
@ -191,7 +191,7 @@ basic_prop_get(const char *propname, void *data, const EDBus_Message *msg)
} }
static void 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; Notifier_Item *item = data;
const char *propname = "AttentionIconName"; const char *propname = "AttentionIconName";
@ -200,14 +200,14 @@ attention_icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pendi
} }
static void 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; 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 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; Notifier_Item *item = data;
const char *propname = "IconName"; const char *propname = "IconName";
@ -216,14 +216,14 @@ icon_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_UN
} }
static void 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; 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 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; Notifier_Item *item = data;
const char *propname = "Title"; const char *propname = "Title";
@ -232,18 +232,18 @@ title_get_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending EINA_U
} }
static void 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; 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 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; Notifier_Item *item = data;
const char *path; const char *path;
if (!edbus_message_arguments_get(msg, "s", &path)) if (!eldbus_message_arguments_get(msg, "s", &path))
{ {
ERR("Error reading message."); ERR("Error reading message.");
return; return;
@ -253,11 +253,11 @@ new_icon_theme_path_cb(void *data, const EDBus_Message *msg)
} }
static void static void
new_status_cb(void *data, const EDBus_Message *msg) new_status_cb(void *data, const Eldbus_Message *msg)
{ {
Notifier_Item *item = data; Notifier_Item *item = data;
const char *status; const char *status;
if (!edbus_message_arguments_get(msg, "s", &status)) if (!eldbus_message_arguments_get(msg, "s", &status))
{ {
ERR("Error reading message."); ERR("Error reading message.");
return; return;
@ -269,9 +269,9 @@ new_status_cb(void *data, const EDBus_Message *msg)
static void static void
notifier_item_add(const char *path, const char *bus_id, Context_Notifier_Host *ctx) 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)); Notifier_Item *item = calloc(1, sizeof(Notifier_Item));
EDBus_Signal_Handler *s; Eldbus_Signal_Handler *s;
EINA_SAFETY_ON_NULL_RETURN(item); EINA_SAFETY_ON_NULL_RETURN(item);
item->path = path; 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, ctx->item_list = eina_inlist_append(ctx->item_list,
EINA_INLIST_GET(item)); 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_IFACE);
item->proxy = proxy; item->proxy = proxy;
edbus_proxy_property_get_all(proxy, props_get_all_cb, item); eldbus_proxy_property_get_all(proxy, props_get_all_cb, item);
s = edbus_proxy_properties_changed_callback_add(proxy, props_changed, item); s = eldbus_proxy_properties_changed_callback_add(proxy, props_changed, item);
item->signals = eina_list_append(item->signals, s); 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); new_attention_icon_cb, item);
item->signals = eina_list_append(item->signals, s); 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); new_icon_cb, item);
item->signals = eina_list_append(item->signals, s); 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); new_icon_theme_path_cb, item);
item->signals = eina_list_append(item->signals, s); 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); 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); item->signals = eina_list_append(item->signals, s);
} }
static void 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; const char *item, *bus, *path;
Context_Notifier_Host *ctx = data; 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."); ERR("Error getting arguments from msg.");
return; return;
@ -317,13 +317,13 @@ notifier_item_add_cb(void *data, const EDBus_Message *msg)
} }
static void 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; const char *service, *bus, *path;
Notifier_Item *item; Notifier_Item *item;
Context_Notifier_Host *ctx = data; 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."); ERR("Error getting arguments from msg.");
return; return;
@ -339,32 +339,32 @@ notifier_item_del_cb(void *data, const EDBus_Message *msg)
} }
static void 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 *item;
const char *error, *error_msg; const char *error, *error_msg;
EDBus_Message_Iter *array, *variant; Eldbus_Message_Iter *array, *variant;
Context_Notifier_Host *ctx = data; 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); ERR("%s %s", error, error_msg);
return; return;
} }
if (!edbus_message_arguments_get(msg, "v", &variant)) if (!eldbus_message_arguments_get(msg, "v", &variant))
{ {
ERR("Error getting arguments from msg."); ERR("Error getting arguments from msg.");
return; 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."); ERR("Error getting arguments from msg.");
return; 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; const char *bus, *path;
if (service_string_parse(item, &path, &bus)) if (service_string_parse(item, &path, &bus))
@ -398,27 +398,27 @@ item_unregistered_local_cb(void *data, const char *service)
} }
static void 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; const char *error, *error_msg;
unsigned flag; unsigned flag;
EDBus_Object *obj; Eldbus_Object *obj;
Context_Notifier_Host *ctx = data; Context_Notifier_Host *ctx = data;
ctx->pending = eina_list_remove(ctx->pending, pending); 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); ERR("%s %s", error, error_msg);
goto end; goto end;
} }
if (!edbus_message_arguments_get(msg, "u", &flag)) if (!eldbus_message_arguments_get(msg, "u", &flag))
{ {
ERR("Error reading message."); ERR("Error reading message.");
goto end; 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, systray_notifier_dbus_watcher_start(ctx->conn,
item_registered_local_cb, item_registered_local_cb,
@ -427,28 +427,28 @@ name_request_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
} }
end: end:
WRN("Bus name: %s already in use, getting data via dbus.\n", WATCHER_BUS); WRN("Bus name: %s already in use, getting data via dbus.\n", WATCHER_BUS);
obj = edbus_object_get(ctx->conn, WATCHER_BUS, WATCHER_PATH); obj = eldbus_object_get(ctx->conn, WATCHER_BUS, WATCHER_PATH);
ctx->watcher = edbus_proxy_get(obj, WATCHER_IFACE); ctx->watcher = eldbus_proxy_get(obj, WATCHER_IFACE);
edbus_proxy_call(ctx->watcher, "RegisterStatusNotifierHost", NULL, NULL, -1, "s", eldbus_proxy_call(ctx->watcher, "RegisterStatusNotifierHost", NULL, NULL, -1, "s",
HOST_REGISTRER); HOST_REGISTRER);
edbus_proxy_property_get(ctx->watcher, "RegisteredStatusNotifierItems", eldbus_proxy_property_get(ctx->watcher, "RegisteredStatusNotifierItems",
notifier_items_get_cb, ctx); 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); 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); notifier_item_del_cb, ctx);
} }
void void
systray_notifier_dbus_init(Context_Notifier_Host *ctx) systray_notifier_dbus_init(Context_Notifier_Host *ctx)
{ {
EDBus_Pending *p; Eldbus_Pending *p;
edbus_init(); eldbus_init();
ctx->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); ctx->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
if (!ctx->conn) return; if (!ctx->conn) return;
p = edbus_name_request(ctx->conn, p = eldbus_name_request(ctx->conn,
WATCHER_BUS, EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, WATCHER_BUS, ELDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING,
name_request_cb, ctx); name_request_cb, ctx);
if (p) ctx->pending = eina_list_append(ctx->pending, p); 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(); systray_notifier_dbus_watcher_stop();
else else
{ {
EDBus_Object *obj; Eldbus_Object *obj;
obj = edbus_proxy_object_get(ctx->watcher); obj = eldbus_proxy_object_get(ctx->watcher);
edbus_proxy_unref(ctx->watcher); eldbus_proxy_unref(ctx->watcher);
edbus_object_unref(obj); eldbus_object_unref(obj);
ctx->watcher = NULL; ctx->watcher = NULL;
} }
edbus_connection_unref(ctx->conn); eldbus_connection_unref(ctx->conn);
edbus_shutdown(); eldbus_shutdown();
} }

8
src/modules/systray/e_mod_notifier_host_private.h
View File

@ -33,8 +33,8 @@ struct _Instance_Notifier_Host
struct _Context_Notifier_Host struct _Context_Notifier_Host
{ {
EDBus_Connection *conn; Eldbus_Connection *conn;
EDBus_Proxy *watcher; Eldbus_Proxy *watcher;
Eina_Inlist *item_list; Eina_Inlist *item_list;
Eina_Inlist *instances; Eina_Inlist *instances;
Eina_List *pending; Eina_List *pending;
@ -45,7 +45,7 @@ struct _Notifier_Item
EINA_INLIST; EINA_INLIST;
const char *bus_id; const char *bus_id;
const char *path; const char *path;
EDBus_Proxy *proxy; Eldbus_Proxy *proxy;
Category category; Category category;
Status status; Status status;
E_DBusMenu_Item *dbus_item; 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_init(Context_Notifier_Host *ctx);
void systray_notifier_dbus_shutdown(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); void systray_notifier_dbus_watcher_stop(void);

80
src/modules/systray/e_mod_notifier_watcher.c
View File

@ -7,8 +7,8 @@
#define ERROR_HOST_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Host.AlreadyRegistered" #define ERROR_HOST_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Host.AlreadyRegistered"
#define ERROR_ITEM_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Item.AlreadyRegistered" #define ERROR_ITEM_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Item.AlreadyRegistered"
static EDBus_Connection *conn = NULL; static Eldbus_Connection *conn = NULL;
static EDBus_Service_Interface *iface = NULL; static Eldbus_Service_Interface *iface = NULL;
static Eina_List *items; static Eina_List *items;
static const char *host_service = NULL; static const char *host_service = NULL;
static E_Notifier_Watcher_Item_Registered_Cb registered_cb; 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, "")) if (strcmp(new_id, ""))
return; return;
edbus_service_signal_emit(iface, ITEM_UNREGISTERED, service); eldbus_service_signal_emit(iface, ITEM_UNREGISTERED, service);
items = eina_list_remove(items, service); items = eina_list_remove(items, service);
if (unregistered_cb) if (unregistered_cb)
unregistered_cb(user_data, service); unregistered_cb(user_data, service);
eina_stringshare_del(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 * static Eldbus_Message *
register_item_cb(const EDBus_Service_Interface *s_iface, const EDBus_Message *msg) register_item_cb(const Eldbus_Service_Interface *s_iface, const Eldbus_Message *msg)
{ {
const char *service; const char *service;
char buf[1024]; char buf[1024];
if (!edbus_message_arguments_get(msg, "s", &service)) if (!eldbus_message_arguments_get(msg, "s", &service))
return NULL; 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); service = eina_stringshare_add(buf);
if (eina_list_data_find(items, service)) if (eina_list_data_find(items, service))
{ {
eina_stringshare_del(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); items = eina_list_append(items, service);
edbus_service_signal_emit(s_iface, ITEM_REGISTERED, service); eldbus_service_signal_emit(s_iface, ITEM_REGISTERED, service);
edbus_name_owner_changed_callback_add(conn, edbus_message_sender_get(msg), eldbus_name_owner_changed_callback_add(conn, eldbus_message_sender_get(msg),
item_name_monitor_cb, service, item_name_monitor_cb, service,
EINA_FALSE); EINA_FALSE);
if (registered_cb) if (registered_cb)
registered_cb(user_data, service); registered_cb(user_data, service);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static void 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, "")) if (strcmp(new_id, ""))
return; return;
edbus_service_signal_emit(iface, HOST_UNREGISTERED); eldbus_service_signal_emit(iface, HOST_UNREGISTERED);
eina_stringshare_del(host_service); eina_stringshare_del(host_service);
host_service = NULL; 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 * static Eldbus_Message *
register_host_cb(const EDBus_Service_Interface *s_iface, const EDBus_Message *msg) register_host_cb(const Eldbus_Service_Interface *s_iface, const Eldbus_Message *msg)
{ {
if (host_service) 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; return NULL;
host_service = eina_stringshare_add(host_service); host_service = eina_stringshare_add(host_service);
edbus_service_signal_emit(s_iface, HOST_REGISTERED); eldbus_service_signal_emit(s_iface, HOST_REGISTERED);
edbus_name_owner_changed_callback_add(conn, edbus_message_sender_get(msg), eldbus_name_owner_changed_callback_add(conn, eldbus_message_sender_get(msg),
host_name_monitor_cb, NULL, EINA_FALSE); host_name_monitor_cb, NULL, EINA_FALSE);
return edbus_message_method_return_new(msg); return eldbus_message_method_return_new(msg);
} }
static Eina_Bool 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")) 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")) else if (!strcmp(propname, "RegisteredStatusNotifierItems"))
{ {
EDBus_Message_Iter *array; Eldbus_Message_Iter *array;
Eina_List *l; Eina_List *l;
const char *service; 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) EINA_LIST_FOREACH(items, l, service)
edbus_message_iter_arguments_append(array, "s", service); eldbus_message_iter_arguments_append(array, "s", service);
edbus_message_iter_container_close(iter, array); eldbus_message_iter_container_close(iter, array);
} }
else if (!strcmp(propname, "IsStatusNotifierHostRegistered")) 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; return EINA_TRUE;
} }
static const EDBus_Property properties[] = static const Eldbus_Property properties[] =
{ {
{ "RegisteredStatusNotifierItems", "as" }, { "RegisteredStatusNotifierItems", "as" },
{ "IsStatusNotifierHostRegistered", "b" }, { "IsStatusNotifierHostRegistered", "b" },
@ -124,33 +124,33 @@ static const EDBus_Property properties[] =
{ } { }
}; };
static const EDBus_Signal signals[] = { static const Eldbus_Signal signals[] = {
{ "StatusNotifierItemRegistered", EDBUS_ARGS({"s", "service"}) }, { "StatusNotifierItemRegistered", ELDBUS_ARGS({"s", "service"}) },
{ "StatusNotifierItemUnregistered", EDBUS_ARGS({"s", "service"}) }, { "StatusNotifierItemUnregistered", ELDBUS_ARGS({"s", "service"}) },
{ "StatusNotifierHostRegistered", NULL }, { "StatusNotifierHostRegistered", NULL },
{ "StatusNotifierHostUnregistered", 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 }, register_item_cb },
{ "RegisterStatusNotifierHost", EDBUS_ARGS({"s", "service"}), NULL, { "RegisterStatusNotifierHost", ELDBUS_ARGS({"s", "service"}), NULL,
register_host_cb }, 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 IFACE, methods, signals, properties, properties_get, NULL
}; };
void 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); EINA_SAFETY_ON_TRUE_RETURN(!!conn);
conn = connection; conn = connection;
iface = edbus_service_interface_register(conn, PATH, &iface_desc); iface = eldbus_service_interface_register(conn, PATH, &iface_desc);
registered_cb = registered; registered_cb = registered;
unregistered_cb = unregistered; unregistered_cb = unregistered;
user_data = (void *)data; user_data = (void *)data;
@ -162,7 +162,7 @@ systray_notifier_dbus_watcher_stop(void)
{ {
const char *txt; const char *txt;
edbus_service_interface_unregister(iface); eldbus_service_interface_unregister(iface);
EINA_LIST_FREE(items, txt) EINA_LIST_FREE(items, txt)
{ {
char *bus; char *bus;
@ -172,7 +172,7 @@ systray_notifier_dbus_watcher_stop(void)
i++; i++;
bus = malloc(sizeof(char) * i); bus = malloc(sizeof(char) * i);
snprintf(bus, i, "%s", txt); 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); free(bus);
eina_stringshare_del(txt); eina_stringshare_del(txt);
} }

28
src/modules/wizard/page_110.c
View File

@ -1,7 +1,7 @@
/* Setup if we need connman? */ /* Setup if we need connman? */
#include "e_wizard.h" #include "e_wizard.h"
#ifdef HAVE_ECONNMAN #ifdef HAVE_ECONNMAN
#include <EDBus.h> #include <Eldbus.h>
#endif #endif
static void static void
@ -38,8 +38,8 @@ _recommend_connman(E_Wizard_Page *pg)
e_wizard_button_next_enable_set(1); e_wizard_button_next_enable_set(1);
} }
static EDBus_Connection *conn; static Eldbus_Connection *conn;
static EDBus_Pending *pending_connman; static Eldbus_Pending *pending_connman;
static Ecore_Timer *connman_timeout = NULL; static Ecore_Timer *connman_timeout = NULL;
static Eina_Bool static Eina_Bool
@ -77,8 +77,8 @@ _page_next_call(void *data EINA_UNUSED)
} }
static void static void
_check_connman_owner(void *data, const EDBus_Message *msg, _check_connman_owner(void *data, const Eldbus_Message *msg,
EDBus_Pending *pending __UNUSED__) Eldbus_Pending *pending __UNUSED__)
{ {
const char *id; const char *id;
pending_connman = NULL; pending_connman = NULL;
@ -89,10 +89,10 @@ _check_connman_owner(void *data, const EDBus_Message *msg,
connman_timeout = NULL; connman_timeout = NULL;
} }
if (edbus_message_error_get(msg, NULL, NULL)) if (eldbus_message_error_get(msg, NULL, NULL))
goto fail; goto fail;
if (!edbus_message_arguments_get(msg, "s", &id)) if (!eldbus_message_arguments_get(msg, "s", &id))
goto fail; goto fail;
if (id[0] != ':') if (id[0] != ':')
@ -124,15 +124,15 @@ wizard_page_show(E_Wizard_Page *pg)
Eina_Bool have_connman = EINA_FALSE; Eina_Bool have_connman = EINA_FALSE;
#ifdef HAVE_ECONNMAN #ifdef HAVE_ECONNMAN
edbus_init(); eldbus_init();
conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
#endif #endif
if (conn) if (conn)
{ {
if (pending_connman) 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); _check_connman_owner, pg);
if (connman_timeout) if (connman_timeout)
ecore_timer_del(connman_timeout); ecore_timer_del(connman_timeout);
@ -168,7 +168,7 @@ wizard_page_hide(E_Wizard_Page *pg __UNUSED__)
{ {
if (pending_connman) if (pending_connman)
{ {
edbus_pending_cancel(pending_connman); eldbus_pending_cancel(pending_connman);
pending_connman = NULL; pending_connman = NULL;
} }
if (connman_timeout) if (connman_timeout)
@ -177,11 +177,11 @@ wizard_page_hide(E_Wizard_Page *pg __UNUSED__)
connman_timeout = NULL; connman_timeout = NULL;
} }
if (conn) if (conn)
edbus_connection_unref(conn); eldbus_connection_unref(conn);
conn = NULL; conn = NULL;
#ifdef HAVE_ECONNMAN #ifdef HAVE_ECONNMAN
edbus_shutdown(); eldbus_shutdown();
#endif #endif
return 1; return 1;