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