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

Rename edbus->eldbus

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

4
ChangeLog
View File

@ -303,9 +303,9 @@
2013-01-03 José Roberto de Souza
* 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
View File

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

2
src/bin/e.h
View File

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

146
src/bin/e_dbusmenu.c
View File

@ -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, &timestamp))
if (!eldbus_message_arguments_get(msg, "iu", &id, &timestamp))
{
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);
}

4
src/bin/e_dbusmenu.h
View File

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

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

@ -71,7 +71,7 @@ static Efm_Mode mode = EFM_MODE_USING_RASTER_MOUNT;
/* FIXME: things to add to the slave enlightenment_fm process and ipc to e:
*
* * 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)
*
*/

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

@ -45,7 +45,7 @@ void *alloca(size_t);
#include <Ecore_Ipc.h>
#include <Ecore_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);
}

26
src/bin/e_fm_cmdline.c
View File

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

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

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

330
src/bin/e_msgbus.c
View File

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

8
src/bin/e_msgbus.h
View File

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

200
src/bin/e_notification.c
View File

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

2
src/bin/e_notification.h
View File

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

10
src/modules/Makefile_music_control.am
View File

@ -14,8 +14,8 @@ music_control_module_la_SOURCES = music-control/e_mod_main.h \
music-control/e_mod_main.c \
music-control/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

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

@ -8,8 +8,8 @@ typedef struct _E_AppMenu_Window E_AppMenu_Window;
typedef struct _E_AppMenu_Context
{
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;

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

@ -16,7 +16,7 @@ void
appmenu_application_monitor(void *data, const char *bus EINA_UNUSED, const char *old __UNUSED__, const char *new __UNUSED__)
{
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,
&registrar_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;
}

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

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

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

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

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

@ -9,15 +9,15 @@ extern Eina_List *device_batteries;
extern Eina_List *device_ac_adapters;
extern 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();
}

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

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

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

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

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

@ -1,5 +1,5 @@
#include <e.h>
#include <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;
}

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

@ -32,7 +32,7 @@ _adap_path_cmp(const void *d1, const void *d2)
const Adapter *adap = d1;
const 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);
}

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

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

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

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

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

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

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

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

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

@ -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();

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

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

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

@ -8,36 +8,36 @@ static const char E_FILEMAN_PATH[] = "/org/enlightenment/FileManager";
typedef struct _E_Fileman_DBus_Daemon E_Fileman_DBus_Daemon;
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", &param_file))
if (!eldbus_message_arguments_get(msg, "s", &param_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();
}

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

@ -18,8 +18,8 @@ static Ecore_Poller *pulse_poller = NULL;
static Eina_Hash *queue_states = NULL;
static 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);

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

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

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

@ -10,35 +10,35 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define 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)
{

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

@ -10,12 +10,12 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define 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)
{

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

@ -10,45 +10,45 @@ static int _log_dom = -1;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#define 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);

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

@ -208,7 +208,7 @@ static const E_Gadcon_Client_Class _gc_class =
EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, _e_music_control_Name };
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);

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

@ -1,923 +0,0 @@
#include "edbus_media_player2_player.h"
static int _log_main = -1;
#undef ERR
#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT;
void
media_player2_player_next_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Next");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_open_uri_call(EDBus_Proxy *proxy, const char *arg0)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "OpenUri");
if (!edbus_message_arguments_append(msg, "s", arg0))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_pause_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Pause");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_play_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Play");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_play_pause_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "PlayPause");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_previous_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Previous");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_seek_call(EDBus_Proxy *proxy, int64_t arg0)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Seek");
if (!edbus_message_arguments_append(msg, "x", arg0))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_set_position_call(EDBus_Proxy *proxy, const char *arg0, int64_t arg1)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "SetPosition");
if (!edbus_message_arguments_append(msg, "ox", arg0, arg1))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_stop_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Stop");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
static void
media_player2_player_seeked_data_free(void *user_data, void *func_data)
{
Media_Player2_Player_Seeked_Data *s_data = user_data;
free(s_data);
}
static void
on_media_player2_player_seeked(void *data, const EDBus_Message *msg)
{
EDBus_Proxy *proxy = data;
Media_Player2_Player_Seeked_Data *s_data = calloc(1, sizeof(Media_Player2_Player_Seeked_Data));
s_data->proxy = proxy;
if (!edbus_message_arguments_get(msg, "x", &s_data->arg0))
{
ERR("Error: Getting arguments from message.");
return;
}
ecore_event_add(MEDIA_PLAYER2_PLAYER_SEEKED_EVENT, s_data, media_player2_player_seeked_data_free, NULL);
}
static void
cb_media_player2_player_can_control(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanControl", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_control_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanControl", cb_media_player2_player_can_control, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_go_next(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanGoNext", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_go_next_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanGoNext", cb_media_player2_player_can_go_next, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_go_previous(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanGoPrevious", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_go_previous_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanGoPrevious", cb_media_player2_player_can_go_previous, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_pause(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanPause", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_pause_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanPause", cb_media_player2_player_can_pause, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_play(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanPlay", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_play_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanPlay", cb_media_player2_player_can_play, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_seek(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanSeek", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_can_seek_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanSeek", cb_media_player2_player_can_seek, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_loop_status(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_String_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
const char *v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
if (!edbus_message_iter_arguments_get(variant, "s", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "LoopStatus", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_loop_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "LoopStatus", cb_media_player2_player_loop_status, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_loop_status_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = edbus_pending_data_del(pending, "__user_data");
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Codegen_Property_Set_Cb cb = data;
if (edbus_message_error_get(msg, &error, &error_msg)) {
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, "LoopStatus", proxy, pending, &error_info);
return;
}
cb(user_data, "LoopStatus", proxy, pending, NULL);
}
EDBus_Pending *
media_player2_player_loop_status_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = edbus_proxy_property_set(proxy, "LoopStatus", "s", value, cb_media_player2_player_loop_status_set, data);
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_maximum_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Double_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
double v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "d", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "MaximumRate", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_maximum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "MaximumRate", cb_media_player2_player_maximum_rate, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_metadata(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Complex_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Metadata", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Metadata", proxy, &error_info, NULL);
return;
}
v = edbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "Metadata", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
EDBus_Pending *
media_player2_player_metadata_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Metadata", cb_media_player2_player_metadata, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_minimum_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Double_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
double v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "d", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "MinimumRate", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_minimum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "MinimumRate", cb_media_player2_player_minimum_rate, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_playback_status(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_String_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
const char *v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
if (!edbus_message_iter_arguments_get(variant, "s", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "PlaybackStatus", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_playback_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "PlaybackStatus", cb_media_player2_player_playback_status, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_position(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Int64_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
int64_t v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "x", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Position", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_position_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Int64_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Position", cb_media_player2_player_position, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_rate(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Double_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
double v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "d", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Rate", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Rate", cb_media_player2_player_rate, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_rate_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = edbus_pending_data_del(pending, "__user_data");
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Codegen_Property_Set_Cb cb = data;
if (edbus_message_error_get(msg, &error, &error_msg)) {
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, "Rate", proxy, pending, &error_info);
return;
}
cb(user_data, "Rate", proxy, pending, NULL);
}
EDBus_Pending *
media_player2_player_rate_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = edbus_proxy_property_set(proxy, "Rate", "d", value, cb_media_player2_player_rate_set, data);
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_shuffle(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Shuffle", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_shuffle_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Shuffle", cb_media_player2_player_shuffle, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_shuffle_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = edbus_pending_data_del(pending, "__user_data");
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Codegen_Property_Set_Cb cb = data;
if (edbus_message_error_get(msg, &error, &error_msg)) {
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, "Shuffle", proxy, pending, &error_info);
return;
}
cb(user_data, "Shuffle", proxy, pending, NULL);
}
EDBus_Pending *
media_player2_player_shuffle_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = edbus_proxy_property_set(proxy, "Shuffle", "b", value, cb_media_player2_player_shuffle_set, data);
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_volume(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Double_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
double v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "d", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Volume", proxy, NULL, v);
}
EDBus_Pending *
media_player2_player_volume_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Volume", cb_media_player2_player_volume, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_volume_set(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = edbus_pending_data_del(pending, "__user_data");
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Codegen_Property_Set_Cb cb = data;
if (edbus_message_error_get(msg, &error, &error_msg)) {
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, "Volume", proxy, pending, &error_info);
return;
}
cb(user_data, "Volume", proxy, pending, NULL);
}
EDBus_Pending *
media_player2_player_volume_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = edbus_proxy_property_set(proxy, "Volume", "d", value, cb_media_player2_player_volume_set, data);
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
void
media_player2_player_log_domain_set(int id)
{
_log_main = id;
}
void
media_player2_player_proxy_unref(EDBus_Proxy *proxy)
{
EDBus_Object *obj = edbus_proxy_object_get(proxy);
edbus_proxy_unref(proxy);
edbus_object_unref(obj);
}
EDBus_Proxy *
media_player2_player_proxy_get(EDBus_Connection *conn, const char *bus, const char *path)
{
EDBus_Object *obj;
EDBus_Proxy *proxy;
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
if (!path) path = "/org/mpris/MediaPlayer2";
obj = edbus_object_get(conn, bus, path);
proxy = edbus_proxy_get(obj, "org.mpris.MediaPlayer2.Player");
edbus_proxy_signal_handler_add(proxy, "Seeked", on_media_player2_player_seeked, proxy);
if (!MEDIA_PLAYER2_PLAYER_SEEKED_EVENT)
MEDIA_PLAYER2_PLAYER_SEEKED_EVENT = ecore_event_type_new();
return proxy;
}

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

@ -1,47 +0,0 @@
#ifndef EDBUS_MEDIA_PLAYER2_PLAYER_H
#define EDBUS_MEDIA_PLAYER2_PLAYER_H
#include <Eina.h>
#include <Ecore.h>
#include <EDBus.h>
#include "edbus_utils.h"
EDBus_Proxy *media_player2_player_proxy_get(EDBus_Connection *conn, const char *bus, const char *path);
void media_player2_player_proxy_unref(EDBus_Proxy *proxy);
void media_player2_player_log_domain_set(int id);
void media_player2_player_next_call(EDBus_Proxy *proxy);
void media_player2_player_open_uri_call(EDBus_Proxy *proxy, const char *arg0);
void media_player2_player_pause_call(EDBus_Proxy *proxy);
void media_player2_player_play_call(EDBus_Proxy *proxy);
void media_player2_player_play_pause_call(EDBus_Proxy *proxy);
void media_player2_player_previous_call(EDBus_Proxy *proxy);
void media_player2_player_seek_call(EDBus_Proxy *proxy, int64_t arg0);
void media_player2_player_set_position_call(EDBus_Proxy *proxy, const char *arg0, int64_t arg1);
void media_player2_player_stop_call(EDBus_Proxy *proxy);
extern int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT;
typedef struct _Media_Player2_Player_Seeked_Data
{
EDBus_Proxy *proxy;
int64_t arg0;
} Media_Player2_Player_Seeked_Data;
EDBus_Pending *media_player2_player_can_control_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_can_go_next_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_can_go_previous_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_can_pause_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_can_play_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_can_seek_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_loop_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_loop_status_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
EDBus_Pending *media_player2_player_maximum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_metadata_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_minimum_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_playback_status_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_position_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Int64_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_rate_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_rate_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
EDBus_Pending *media_player2_player_shuffle_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_shuffle_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
EDBus_Pending *media_player2_player_volume_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Double_Get_Cb cb, const void *data);
EDBus_Pending *media_player2_player_volume_propset(EDBus_Proxy *proxy, EDBus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
#endif

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

@ -1,350 +0,0 @@
#include "edbus_mpris_media_player2.h"
static int _log_main = -1;
#undef ERR
#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
void
mpris_media_player2_quit_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Quit");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
mpris_media_player2_raise_call(EDBus_Proxy *proxy)
{
EDBus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = edbus_proxy_method_call_new(proxy, "Raise");
if (!edbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
edbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
static void
cb_mpris_media_player2_can_quit(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanQuit", proxy, NULL, v);
}
EDBus_Pending *
mpris_media_player2_can_quit_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanQuit", cb_mpris_media_player2_can_quit, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_can_raise(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanRaise", proxy, NULL, v);
}
EDBus_Pending *
mpris_media_player2_can_raise_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "CanRaise", cb_mpris_media_player2_can_raise, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_desktop_entry(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_String_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
const char *v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
if (!edbus_message_iter_arguments_get(variant, "s", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "DesktopEntry", proxy, NULL, v);
}
EDBus_Pending *
mpris_media_player2_desktop_entry_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "DesktopEntry", cb_mpris_media_player2_desktop_entry, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_has_track_list(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Bool_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Bool v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
if (!edbus_message_iter_arguments_get(variant, "b", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "HasTrackList", proxy, NULL, v);
}
EDBus_Pending *
mpris_media_player2_has_track_list_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "HasTrackList", cb_mpris_media_player2_has_track_list, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_identity(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_String_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
const char *v;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
if (!edbus_message_iter_arguments_get(variant, "s", &v))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "Identity", proxy, NULL, v);
}
EDBus_Pending *
mpris_media_player2_identity_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "Identity", cb_mpris_media_player2_identity, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_supported_mime_types(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Complex_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL);
return;
}
v = edbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "SupportedMimeTypes", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
EDBus_Pending *
mpris_media_player2_supported_mime_types_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "SupportedMimeTypes", cb_mpris_media_player2_supported_mime_types, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_supported_uri_schemes(void *data, const EDBus_Message *msg, EDBus_Pending *pending)
{
void *user_data = edbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
EDBus_Codegen_Property_Complex_Get_Cb cb = data;
EDBus_Proxy *proxy = edbus_pending_data_del(pending, "__proxy");
EDBus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (edbus_message_error_get(msg, &error, &error_msg))
{
EDBus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
if (!edbus_message_arguments_get(msg, "v", &variant))
{
EDBus_Error_Info error_info = {"", ""};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
v = edbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "SupportedUriSchemes", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
EDBus_Pending *
mpris_media_player2_supported_uri_schemes_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
EDBus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = edbus_proxy_property_get(proxy, "SupportedUriSchemes", cb_mpris_media_player2_supported_uri_schemes, cb);
if (data)
edbus_pending_data_set(p, "__user_data", data);
edbus_pending_data_set(p, "__proxy", proxy);
return p;
}
void
mpris_media_player2_log_domain_set(int id)
{
_log_main = id;
}
void
mpris_media_player2_proxy_unref(EDBus_Proxy *proxy)
{
EDBus_Object *obj = edbus_proxy_object_get(proxy);
edbus_proxy_unref(proxy);
edbus_object_unref(obj);
}
EDBus_Proxy *
mpris_media_player2_proxy_get(EDBus_Connection *conn, const char *bus, const char *path)
{
EDBus_Object *obj;
EDBus_Proxy *proxy;
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
if (!path) path = "/org/mpris/MediaPlayer2";
obj = edbus_object_get(conn, bus, path);
proxy = edbus_proxy_get(obj, "org.mpris.MediaPlayer2");
return proxy;
}

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

@ -1,22 +0,0 @@
#ifndef EDBUS_MPRIS_MEDIA_PLAYER2_H
#define EDBUS_MPRIS_MEDIA_PLAYER2_H
#include <Eina.h>
#include <Ecore.h>
#include <EDBus.h>
#include "edbus_utils.h"
EDBus_Proxy *mpris_media_player2_proxy_get(EDBus_Connection *conn, const char *bus, const char *path);
void mpris_media_player2_proxy_unref(EDBus_Proxy *proxy);
void mpris_media_player2_log_domain_set(int id);
void mpris_media_player2_quit_call(EDBus_Proxy *proxy);
void mpris_media_player2_raise_call(EDBus_Proxy *proxy);
EDBus_Pending *mpris_media_player2_can_quit_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_can_raise_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_desktop_entry_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_has_track_list_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Bool_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_identity_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_String_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_supported_mime_types_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data);
EDBus_Pending *mpris_media_player2_supported_uri_schemes_propget(EDBus_Proxy *proxy, EDBus_Codegen_Property_Complex_Get_Cb cb, const void *data);
#endif

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

@ -1,24 +0,0 @@
#ifndef EDBUS_UTILS_H
#define EDBUS_UTILS_H 1
typedef struct _EDBus_Error_Info
{
const char *error;
const char *message;
} EDBus_Error_Info;
typedef void (*EDBus_Codegen_Property_Set_Cb)(void *data, const char *propname, EDBus_Proxy *proxy, EDBus_Pending *p, EDBus_Error_Info *error_info);
typedef void (*EDBus_Codegen_Property_String_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, const char *value);
typedef void (*EDBus_Codegen_Property_Int32_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, int value);
typedef void (*EDBus_Codegen_Property_Byte_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned char value);
typedef void (*EDBus_Codegen_Property_Bool_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, Eina_Bool value);
typedef void (*EDBus_Codegen_Property_Int16_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, short int value);
typedef void (*EDBus_Codegen_Property_Uint16_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned short int value);
typedef void (*EDBus_Codegen_Property_Uint32_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, unsigned int value);
typedef void (*EDBus_Codegen_Property_Double_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, double value);
typedef void (*EDBus_Codegen_Property_Int64_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, int64_t value);
typedef void (*EDBus_Codegen_Property_Uint64_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, uint64_t value);
typedef void (*EDBus_Codegen_Property_Complex_Get_Cb)(void *data, EDBus_Pending *p, const char *propname, EDBus_Proxy *proxy, EDBus_Error_Info *error_info, Eina_Value *value);
#endif

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

@ -0,0 +1,923 @@
#include "eldbus_media_player2_player.h"
static int _log_main = -1;
#undef ERR
#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT;
void
media_player2_player_next_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Next");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_open_uri_call(Eldbus_Proxy *proxy, const char *arg0)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "OpenUri");
if (!eldbus_message_arguments_append(msg, "s", arg0))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_pause_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Pause");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_play_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Play");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_play_pause_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "PlayPause");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_previous_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Previous");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_seek_call(Eldbus_Proxy *proxy, int64_t arg0)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Seek");
if (!eldbus_message_arguments_append(msg, "x", arg0))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_set_position_call(Eldbus_Proxy *proxy, const char *arg0, int64_t arg1)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "SetPosition");
if (!eldbus_message_arguments_append(msg, "ox", arg0, arg1))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
media_player2_player_stop_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Stop");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
static void
media_player2_player_seeked_data_free(void *user_data, void *func_data)
{
Media_Player2_Player_Seeked_Data *s_data = user_data;
free(s_data);
}
static void
on_media_player2_player_seeked(void *data, const Eldbus_Message *msg)
{
Eldbus_Proxy *proxy = data;
Media_Player2_Player_Seeked_Data *s_data = calloc(1, sizeof(Media_Player2_Player_Seeked_Data));
s_data->proxy = proxy;
if (!eldbus_message_arguments_get(msg, "x", &s_data->arg0))
{
ERR("Error: Getting arguments from message.");
return;
}
ecore_event_add(MEDIA_PLAYER2_PLAYER_SEEKED_EVENT, s_data, media_player2_player_seeked_data_free, NULL);
}
static void
cb_media_player2_player_can_control(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanControl", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanControl", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_control_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanControl", cb_media_player2_player_can_control, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_go_next(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoNext", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanGoNext", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_go_next_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanGoNext", cb_media_player2_player_can_go_next, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_go_previous(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanGoPrevious", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanGoPrevious", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_go_previous_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanGoPrevious", cb_media_player2_player_can_go_previous, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_pause(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPause", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanPause", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_pause_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanPause", cb_media_player2_player_can_pause, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_play(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanPlay", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanPlay", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_play_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanPlay", cb_media_player2_player_can_play, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_can_seek(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanSeek", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanSeek", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_can_seek_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanSeek", cb_media_player2_player_can_seek, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_loop_status(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_String_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
const char *v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "s", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "LoopStatus", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "LoopStatus", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_loop_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "LoopStatus", cb_media_player2_player_loop_status, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_loop_status_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = eldbus_pending_data_del(pending, "__user_data");
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Codegen_Property_Set_Cb cb = data;
if (eldbus_message_error_get(msg, &error, &error_msg)) {
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, "LoopStatus", proxy, pending, &error_info);
return;
}
cb(user_data, "LoopStatus", proxy, pending, NULL);
}
Eldbus_Pending *
media_player2_player_loop_status_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = eldbus_proxy_property_set(proxy, "LoopStatus", "s", value, cb_media_player2_player_loop_status_set, data);
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_maximum_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Double_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
double v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "d", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MaximumRate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "MaximumRate", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_maximum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "MaximumRate", cb_media_player2_player_maximum_rate, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_metadata(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Complex_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Metadata", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Metadata", proxy, &error_info, NULL);
return;
}
v = eldbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "Metadata", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
Eldbus_Pending *
media_player2_player_metadata_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Metadata", cb_media_player2_player_metadata, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_minimum_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Double_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
double v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "d", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "MinimumRate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "MinimumRate", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_minimum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "MinimumRate", cb_media_player2_player_minimum_rate, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_playback_status(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_String_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
const char *v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "s", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "PlaybackStatus", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "PlaybackStatus", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_playback_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "PlaybackStatus", cb_media_player2_player_playback_status, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_position(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Int64_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
int64_t v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "x", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Position", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Position", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_position_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Int64_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Position", cb_media_player2_player_position, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_rate(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Double_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
double v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "d", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Rate", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Rate", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Rate", cb_media_player2_player_rate, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_rate_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = eldbus_pending_data_del(pending, "__user_data");
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Codegen_Property_Set_Cb cb = data;
if (eldbus_message_error_get(msg, &error, &error_msg)) {
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, "Rate", proxy, pending, &error_info);
return;
}
cb(user_data, "Rate", proxy, pending, NULL);
}
Eldbus_Pending *
media_player2_player_rate_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = eldbus_proxy_property_set(proxy, "Rate", "d", value, cb_media_player2_player_rate_set, data);
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_shuffle(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Shuffle", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Shuffle", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_shuffle_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Shuffle", cb_media_player2_player_shuffle, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_shuffle_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = eldbus_pending_data_del(pending, "__user_data");
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Codegen_Property_Set_Cb cb = data;
if (eldbus_message_error_get(msg, &error, &error_msg)) {
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, "Shuffle", proxy, pending, &error_info);
return;
}
cb(user_data, "Shuffle", proxy, pending, NULL);
}
Eldbus_Pending *
media_player2_player_shuffle_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = eldbus_proxy_property_set(proxy, "Shuffle", "b", value, cb_media_player2_player_shuffle_set, data);
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_volume(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Double_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
double v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "d", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Volume", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "Volume", proxy, NULL, v);
}
Eldbus_Pending *
media_player2_player_volume_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Volume", cb_media_player2_player_volume, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_media_player2_player_volume_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
const char *error, *error_msg;
void *user_data = eldbus_pending_data_del(pending, "__user_data");
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Codegen_Property_Set_Cb cb = data;
if (eldbus_message_error_get(msg, &error, &error_msg)) {
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, "Volume", proxy, pending, &error_info);
return;
}
cb(user_data, "Volume", proxy, pending, NULL);
}
Eldbus_Pending *
media_player2_player_volume_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
p = eldbus_proxy_property_set(proxy, "Volume", "d", value, cb_media_player2_player_volume_set, data);
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
void
media_player2_player_log_domain_set(int id)
{
_log_main = id;
}
void
media_player2_player_proxy_unref(Eldbus_Proxy *proxy)
{
Eldbus_Object *obj = eldbus_proxy_object_get(proxy);
eldbus_proxy_unref(proxy);
eldbus_object_unref(obj);
}
Eldbus_Proxy *
media_player2_player_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path)
{
Eldbus_Object *obj;
Eldbus_Proxy *proxy;
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
if (!path) path = "/org/mpris/MediaPlayer2";
obj = eldbus_object_get(conn, bus, path);
proxy = eldbus_proxy_get(obj, "org.mpris.MediaPlayer2.Player");
eldbus_proxy_signal_handler_add(proxy, "Seeked", on_media_player2_player_seeked, proxy);
if (!MEDIA_PLAYER2_PLAYER_SEEKED_EVENT)
MEDIA_PLAYER2_PLAYER_SEEKED_EVENT = ecore_event_type_new();
return proxy;
}

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

@ -0,0 +1,47 @@
#ifndef ELDBUS_MEDIA_PLAYER2_PLAYER_H
#define ELDBUS_MEDIA_PLAYER2_PLAYER_H
#include <Eina.h>
#include <Ecore.h>
#include <Eldbus.h>
#include "eldbus_utils.h"
Eldbus_Proxy *media_player2_player_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path);
void media_player2_player_proxy_unref(Eldbus_Proxy *proxy);
void media_player2_player_log_domain_set(int id);
void media_player2_player_next_call(Eldbus_Proxy *proxy);
void media_player2_player_open_uri_call(Eldbus_Proxy *proxy, const char *arg0);
void media_player2_player_pause_call(Eldbus_Proxy *proxy);
void media_player2_player_play_call(Eldbus_Proxy *proxy);
void media_player2_player_play_pause_call(Eldbus_Proxy *proxy);
void media_player2_player_previous_call(Eldbus_Proxy *proxy);
void media_player2_player_seek_call(Eldbus_Proxy *proxy, int64_t arg0);
void media_player2_player_set_position_call(Eldbus_Proxy *proxy, const char *arg0, int64_t arg1);
void media_player2_player_stop_call(Eldbus_Proxy *proxy);
extern int MEDIA_PLAYER2_PLAYER_SEEKED_EVENT;
typedef struct _Media_Player2_Player_Seeked_Data
{
Eldbus_Proxy *proxy;
int64_t arg0;
} Media_Player2_Player_Seeked_Data;
Eldbus_Pending *media_player2_player_can_control_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_can_go_next_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_can_go_previous_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_can_pause_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_can_play_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_can_seek_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_loop_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_loop_status_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
Eldbus_Pending *media_player2_player_maximum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_metadata_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_minimum_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_playback_status_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_position_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Int64_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_rate_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_rate_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
Eldbus_Pending *media_player2_player_shuffle_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_shuffle_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
Eldbus_Pending *media_player2_player_volume_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
Eldbus_Pending *media_player2_player_volume_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
#endif

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

@ -0,0 +1,350 @@
#include "eldbus_mpris_media_player2.h"
static int _log_main = -1;
#undef ERR
#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
void
mpris_media_player2_quit_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Quit");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
void
mpris_media_player2_raise_call(Eldbus_Proxy *proxy)
{
Eldbus_Message *msg;
EINA_SAFETY_ON_NULL_RETURN(proxy);
msg = eldbus_proxy_method_call_new(proxy, "Raise");
if (!eldbus_message_arguments_append(msg, ""))
{
ERR("Error: Filling message.");
return;
}
eldbus_proxy_send(proxy, msg, NULL, NULL, -1);
}
static void
cb_mpris_media_player2_can_quit(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanQuit", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanQuit", proxy, NULL, v);
}
Eldbus_Pending *
mpris_media_player2_can_quit_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanQuit", cb_mpris_media_player2_can_quit, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_can_raise(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "CanRaise", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "CanRaise", proxy, NULL, v);
}
Eldbus_Pending *
mpris_media_player2_can_raise_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "CanRaise", cb_mpris_media_player2_can_raise, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_desktop_entry(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_String_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
const char *v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "s", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "DesktopEntry", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "DesktopEntry", proxy, NULL, v);
}
Eldbus_Pending *
mpris_media_player2_desktop_entry_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "DesktopEntry", cb_mpris_media_player2_desktop_entry, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_has_track_list(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Bool v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "b", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "HasTrackList", proxy, &error_info, 0);
return;
}
cb(user_data, pending, "HasTrackList", proxy, NULL, v);
}
Eldbus_Pending *
mpris_media_player2_has_track_list_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "HasTrackList", cb_mpris_media_player2_has_track_list, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_identity(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_String_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
const char *v;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_iter_arguments_get(variant, "s", &v))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "Identity", proxy, &error_info, NULL);
return;
}
cb(user_data, pending, "Identity", proxy, NULL, v);
}
Eldbus_Pending *
mpris_media_player2_identity_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "Identity", cb_mpris_media_player2_identity, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_supported_mime_types(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Complex_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "SupportedMimeTypes", proxy, &error_info, NULL);
return;
}
v = eldbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "SupportedMimeTypes", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
Eldbus_Pending *
mpris_media_player2_supported_mime_types_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "SupportedMimeTypes", cb_mpris_media_player2_supported_mime_types, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
static void
cb_mpris_media_player2_supported_uri_schemes(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Complex_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
v = eldbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "SupportedUriSchemes", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
Eldbus_Pending *
mpris_media_player2_supported_uri_schemes_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data)
{
Eldbus_Pending *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
p = eldbus_proxy_property_get(proxy, "SupportedUriSchemes", cb_mpris_media_player2_supported_uri_schemes, cb);
if (data)
eldbus_pending_data_set(p, "__user_data", data);
eldbus_pending_data_set(p, "__proxy", proxy);
return p;
}
void
mpris_media_player2_log_domain_set(int id)
{
_log_main = id;
}
void
mpris_media_player2_proxy_unref(Eldbus_Proxy *proxy)
{
Eldbus_Object *obj = eldbus_proxy_object_get(proxy);
eldbus_proxy_unref(proxy);
eldbus_object_unref(obj);
}
Eldbus_Proxy *
mpris_media_player2_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path)
{
Eldbus_Object *obj;
Eldbus_Proxy *proxy;
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
if (!path) path = "/org/mpris/MediaPlayer2";
obj = eldbus_object_get(conn, bus, path);
proxy = eldbus_proxy_get(obj, "org.mpris.MediaPlayer2");
return proxy;
}

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

@ -0,0 +1,22 @@
#ifndef ELDBUS_MPRIS_MEDIA_PLAYER2_H
#define ELDBUS_MPRIS_MEDIA_PLAYER2_H
#include <Eina.h>
#include <Ecore.h>
#include <Eldbus.h>
#include "eldbus_utils.h"
Eldbus_Proxy *mpris_media_player2_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path);
void mpris_media_player2_proxy_unref(Eldbus_Proxy *proxy);
void mpris_media_player2_log_domain_set(int id);
void mpris_media_player2_quit_call(Eldbus_Proxy *proxy);
void mpris_media_player2_raise_call(Eldbus_Proxy *proxy);
Eldbus_Pending *mpris_media_player2_can_quit_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_can_raise_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_desktop_entry_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_has_track_list_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_identity_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_supported_mime_types_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data);
Eldbus_Pending *mpris_media_player2_supported_uri_schemes_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Complex_Get_Cb cb, const void *data);
#endif

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

@ -0,0 +1,24 @@
#ifndef ELDBUS_UTILS_H
#define ELDBUS_UTILS_H 1
typedef struct _Eldbus_Error_Info
{
const char *error;
const char *message;
} Eldbus_Error_Info;
typedef void (*Eldbus_Codegen_Property_Set_Cb)(void *data, const char *propname, Eldbus_Proxy *proxy, Eldbus_Pending *p, Eldbus_Error_Info *error_info);
typedef void (*Eldbus_Codegen_Property_String_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, const char *value);
typedef void (*Eldbus_Codegen_Property_Int32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int value);
typedef void (*Eldbus_Codegen_Property_Byte_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned char value);
typedef void (*Eldbus_Codegen_Property_Bool_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Bool value);
typedef void (*Eldbus_Codegen_Property_Int16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, short int value);
typedef void (*Eldbus_Codegen_Property_Uint16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned short int value);
typedef void (*Eldbus_Codegen_Property_Uint32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned int value);
typedef void (*Eldbus_Codegen_Property_Double_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, double value);
typedef void (*Eldbus_Codegen_Property_Int64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int64_t value);
typedef void (*Eldbus_Codegen_Property_Uint64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, uint64_t value);
typedef void (*Eldbus_Codegen_Property_Complex_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Value *value);
#endif

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

@ -2,8 +2,8 @@
#define MUSIC_CONTROL_PRIVATE_H
#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;

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

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

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

@ -57,78 +57,78 @@ id_find(const char *s, const char *names[])
}
static void
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();
}

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

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

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

@ -7,8 +7,8 @@
#define ERROR_HOST_ALREADY_REGISTERED "org.kde.StatusNotifierWatcher.Host.AlreadyRegistered"
#define ERROR_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);
}

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

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