diff --git a/legacy/ethumb/configure.ac b/legacy/ethumb/configure.ac index f5d98d0726..07768acba4 100644 --- a/legacy/ethumb/configure.ac +++ b/legacy/ethumb/configure.ac @@ -153,7 +153,7 @@ fi AM_CONDITIONAL(HAVE_EDBUS, false) define([CHECK_MODULE_ETHUMBD], [ - AC_ETH_CHECK_PKG(EDBUS, edbus, [], [ETHUMBD=false]) + AC_ETH_CHECK_PKG(EDBUS, edbus2, [], [ETHUMBD=false]) ]) AC_ETH_OPTIONAL_MODULE([ethumbd], true, [CHECK_MODULE_ETHUMBD]) diff --git a/legacy/ethumb/src/bin/Makefile.am b/legacy/ethumb/src/bin/Makefile.am index 2558cfff74..7c856146f8 100644 --- a/legacy/ethumb/src/bin/Makefile.am +++ b/legacy/ethumb/src/bin/Makefile.am @@ -48,6 +48,7 @@ ethumbd_client_SOURCES = ethumbd_client.c ethumbd_client_LDADD = \ $(top_builddir)/src/lib/client/libethumb_client.la \ $(top_builddir)/src/lib/libethumb.la \ +@EDBUS_LIBS@ \ @ECORE_LIBS@ \ @EINA_LIBS@ diff --git a/legacy/ethumb/src/bin/ethumbd.c b/legacy/ethumb/src/bin/ethumbd.c index 4b1bcb3fa4..c35d1ac303 100644 --- a/legacy/ethumb/src/bin/ethumbd.c +++ b/legacy/ethumb/src/bin/ethumbd.c @@ -33,7 +33,7 @@ #include #include #include -#include +#include #include #include "ethumbd_private.h" @@ -43,6 +43,8 @@ #endif #define MAX_ID 2000000 +#define DAEMON "daemon" +#define ODATA "odata" #define DBG(...) EINA_LOG_DOM_DBG(_log_domain, __VA_ARGS__) #define INF(...) EINA_LOG_DOM_INFO(_log_domain, __VA_ARGS__) @@ -129,7 +131,7 @@ struct _Ethumbd_Object int id_count; int max_id; int min_id; - E_DBus_Object *dbus_obj; + EDBus_Service_Interface *iface; }; struct _Ethumbd_Queue @@ -153,10 +155,7 @@ struct _Ethumbd_Slave struct _Ethumbd { - E_DBus_Connection *conn; - E_DBus_Signal_Handler *name_owner_changed_handler; - E_DBus_Interface *eiface, *objects_iface; - E_DBus_Object *dbus_obj; + EDBus_Connection *conn; Ecore_Idler *idler; Ethumbd_Request *processing; Ethumbd_Queue queue; @@ -174,20 +173,6 @@ struct _Ethumbd_Object_Data Ethumbd *ed; }; -struct _Ethumb_DBus_Method_Table -{ - const char *name; - const char *signature; - const char *reply; - E_DBus_Method_Cb function; -}; - -struct _Ethumb_DBus_Signal_Table -{ - const char *name; - const char *signature; -}; - const Ecore_Getopt optdesc = { "ethumbd", NULL, @@ -210,6 +195,44 @@ const Ecore_Getopt optdesc = { } }; +static EDBus_Message *_ethumb_dbus_queue_add_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); +static EDBus_Message *_ethumb_dbus_queue_remove_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); +static EDBus_Message *_ethumb_dbus_queue_clear_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); +static EDBus_Message *_ethumb_dbus_ethumb_setup_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); +static EDBus_Message *_ethumb_dbus_delete_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg); + +static const EDBus_Method _ethumb_dbus_objects_methods[] = { + { + "queue_add", + EDBUS_ARGS({"i", "id"}, {"ay", "file"}, {"ay", "key"}, {"ay", "thumb"}, {"ay", "thumb_key"}), + EDBUS_ARGS({"i", "queue_id"}), _ethumb_dbus_queue_add_cb, 0 + }, + { + "queue_remove", EDBUS_ARGS({"i", "queue_id"}), EDBUS_ARGS({"b", "result"}), + _ethumb_dbus_queue_remove_cb, 0 + }, + { + "clear_queue", NULL, NULL, _ethumb_dbus_queue_clear_cb, 0 + }, + { + "ethumb_setup", EDBUS_ARGS({"a{sv}", "array"}), EDBUS_ARGS({"b", "result"}), + _ethumb_dbus_ethumb_setup_cb, 0 + }, + { + "delete", NULL, NULL, _ethumb_dbus_delete_cb, 0 + }, + { } +}; + +static const EDBus_Signal _ethumb_dbus_objects_signals[] = { + { + "generated", + EDBUS_ARGS({"i", ""}, {"ay", "array"}, {"ay", "array"}, {"b", "bool"}), + 0 + }, + { } +}; + static void _ethumb_dbus_generated_signal(Ethumbd *ed, int *id, const char *thumb_path, const char *thumb_key, Eina_Bool success); static Eina_Bool _ethumbd_slave_spawn(Ethumbd_Slave *slave, Ethumbd *ed); @@ -801,12 +824,13 @@ _get_idx_for_path(const char *path) return i; } +static void _name_owner_changed_cb(void *context, const char *bus, const char *old_id, const char *new_id); + static void _ethumb_table_del(Ethumbd *ed, int i) { int j; Eina_List *l; - const Eina_List *il; Ethumbd_Queue *q = &ed->queue; Ethumbd_Object_Data *odata; @@ -825,15 +849,13 @@ _ethumb_table_del(Ethumbd *ed, int i) } q->nqueue -= q->table[i].nqueue; - il = e_dbus_object_interfaces_get(q->table[i].dbus_obj); - while (il) - { - e_dbus_object_interface_detach(q->table[i].dbus_obj, il->data); - il = e_dbus_object_interfaces_get(q->table[i].dbus_obj); - } - odata = e_dbus_object_data_get(q->table[i].dbus_obj); + odata = edbus_service_object_data_del(q->table[i].iface, ODATA); + edbus_name_owner_changed_callback_del(ed->conn, ed->queue.table[i].client, + _name_owner_changed_cb, odata); + //this string was not been freed previously + eina_stringshare_del(ed->queue.table[i].client); free(odata); - e_dbus_object_free(q->table[i].dbus_obj); + edbus_service_object_unregister(q->table[i].iface); memset(&(q->table[i]), 0, sizeof(Ethumbd_Object)); for (j = 0; j < q->count; j++) @@ -859,65 +881,36 @@ _ethumb_table_clear(Ethumbd *ed) } static void -_name_owner_changed_cb(void *data, DBusMessage *msg) +_name_owner_changed_cb(void *context, const char *bus, const char *old_id, const char *new_id) { - DBusError err; - Ethumbd *ed = data; + Ethumbd_Object_Data *odata = context; + Ethumbd *ed = odata->ed; Ethumbd_Queue *q = &ed->queue; - const char *name, *from, *to; - int i; - dbus_error_init(&err); - if (!dbus_message_get_args(msg, &err, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_STRING, &from, - DBUS_TYPE_STRING, &to, - DBUS_TYPE_INVALID)) - { - ERR("could not get NameOwnerChanged arguments: %s: %s", - err.name, err.message); - dbus_error_free(&err); - return; - } - - DBG("NameOwnerChanged: name = %s, from = %s, to = %s", name, from, to); - - if (from[0] == '\0' || to[0] != '\0') + DBG("NameOwnerChanged: name = %s, from = %s, to = %s", bus, old_id, new_id); + if (new_id[0]) return; - - from = eina_stringshare_add(from); - for (i = 0; i < q->max_count; i++) - { - if (q->table[i].used && q->table[i].client == from) - { - _ethumb_table_del(ed, i); - DBG("deleting [%d] from queue table.", i); - } - } + _ethumb_table_del(ed, odata->idx); } -static void -_ethumb_dbus_add_name_owner_changed_cb(Ethumbd *ed) -{ - ed->name_owner_changed_handler = e_dbus_signal_handler_add - (ed->conn, fdo_bus_name, fdo_path, fdo_interface, "NameOwnerChanged", - _name_owner_changed_cb, ed); -} +static const EDBus_Service_Interface_Desc client_desc = { + _ethumb_dbus_objects_interface, _ethumb_dbus_objects_methods, + _ethumb_dbus_objects_signals +}; -DBusMessage * -_ethumb_dbus_ethumb_new_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_ethumb_new_cb(const EDBus_Service_Interface *interface, const EDBus_Message *msg) { - DBusMessage *reply; - DBusMessageIter iter; - E_DBus_Object *dbus_object; + EDBus_Message *reply; + EDBus_Service_Interface *iface; Ethumbd_Object_Data *odata; int i; const char *return_path = ""; const char *client; Ethumbd *ed; - ed = e_dbus_object_data_get(object); - client = dbus_message_get_sender(msg); + ed = edbus_service_object_data_get(interface, DAEMON); + client = edbus_message_sender_get(msg); if (!client) goto end_new; @@ -932,53 +925,48 @@ _ethumb_dbus_ethumb_new_cb(E_DBus_Object *object, DBusMessage *msg) ed->queue.table[i].client = eina_stringshare_add(client); return_path = ed->queue.table[i].path; - dbus_object = e_dbus_object_add(ed->conn, return_path, odata); - if (!dbus_object) + iface = edbus_service_interface_register(ed->conn, return_path, &client_desc); + if (!iface) { ERR("could not create dbus_object."); free(odata); return_path = ""; goto end_new; } - - e_dbus_object_interface_attach(dbus_object, ed->objects_iface); - ed->queue.table[i].dbus_obj = dbus_object; - + edbus_service_object_data_set(iface, ODATA, odata); + ed->queue.table[i].iface = iface; + edbus_name_owner_changed_callback_add(ed->conn, client, + _name_owner_changed_cb, odata, + EINA_TRUE); _ethumbd_child_write_op_new(&ed->slave, i); _ethumbd_timeout_stop(ed); end_new: - reply = dbus_message_new_method_return(msg); - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, - &return_path); + reply = edbus_message_method_return_new(msg); + edbus_message_arguments_set(reply, "o", return_path); return reply; } -static struct _Ethumb_DBus_Method_Table _ethumb_dbus_methods[] = - { - {"new", "", "o", _ethumb_dbus_ethumb_new_cb}, - {NULL, NULL, NULL, NULL} - }; +static const EDBus_Method _ethumb_dbus_methods[] = { + { + "new", NULL, EDBUS_ARGS({"o", "path"}), _ethumb_dbus_ethumb_new_cb, 0 + }, + { } +}; static const char * -_ethumb_dbus_get_bytearray(DBusMessageIter *iter) +_ethumb_dbus_get_bytearray(EDBus_Message_Iter *iter) { - int el_type; int length; - DBusMessageIter riter; const char *result; - el_type = dbus_message_iter_get_element_type(iter); - if (el_type != DBUS_TYPE_BYTE) + if (!edbus_message_iter_fixed_array_get(iter, 'y', &result, + &length)) { - ERR("not an byte array element."); - return NULL; + ERR("not an byte array element."); + return NULL; } - dbus_message_iter_recurse(iter, &riter); - dbus_message_iter_get_fixed_array(&riter, &result, &length); - if ((length == 0) || (result[0] == '\0')) return NULL; else @@ -986,42 +974,41 @@ _ethumb_dbus_get_bytearray(DBusMessageIter *iter) } static void -_ethumb_dbus_append_bytearray(DBusMessageIter *iter, const char *string) +_ethumb_dbus_append_bytearray(EDBus_Message_Iter *parent, EDBus_Message_Iter *array, const char *string) { - DBusMessageIter viter; + int i, size; if (!string) string = ""; - dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "y", &viter); - dbus_message_iter_append_fixed_array - (&viter, DBUS_TYPE_BYTE, &string, strlen(string) + 1); - dbus_message_iter_close_container(iter, &viter); + size = strlen(string); + for (i = 0; i < size; i++) + edbus_message_iter_basic_append(array, 'y', string[i]); + edbus_message_iter_container_close(parent, array); } -DBusMessage * -_ethumb_dbus_queue_add_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_queue_add_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { - DBusMessage *reply; - DBusMessageIter iter; - const char *file, *key; - const char *thumb, *thumb_key; + EDBus_Message *reply; + const char *file, *key, *thumb, *thumb_key; Ethumbd_Object_Data *odata; Ethumbd_Object *eobject; Ethumbd *ed; Ethumbd_Request *request; - dbus_int32_t id = -1; + int id = -1; + EDBus_Message_Iter *file_iter, *key_iter, *thumb_iter, *thumb_key_iter; - dbus_message_iter_init(msg, &iter); - dbus_message_iter_get_basic(&iter, &id); - dbus_message_iter_next(&iter); - file = _ethumb_dbus_get_bytearray(&iter); - dbus_message_iter_next(&iter); - key = _ethumb_dbus_get_bytearray(&iter); - dbus_message_iter_next(&iter); - thumb = _ethumb_dbus_get_bytearray(&iter); - dbus_message_iter_next(&iter); - thumb_key = _ethumb_dbus_get_bytearray(&iter); + if (!edbus_message_arguments_get(msg, "iayayayay", &id, &file_iter, + &key_iter, &thumb_iter, &thumb_key_iter)) + { + ERR("Error getting arguments."); + goto end; + } + file = _ethumb_dbus_get_bytearray(file_iter); + key = _ethumb_dbus_get_bytearray(key_iter); + thumb = _ethumb_dbus_get_bytearray(thumb_iter); + thumb_key = _ethumb_dbus_get_bytearray(thumb_key_iter); if (!file) { @@ -1029,7 +1016,7 @@ _ethumb_dbus_queue_add_cb(E_DBus_Object *object, DBusMessage *msg) goto end; } - odata = e_dbus_object_data_get(object); + odata = edbus_service_object_data_get(iface, ODATA); if (!odata) { ERR("could not get dbus_object data."); @@ -1053,30 +1040,30 @@ _ethumb_dbus_queue_add_cb(E_DBus_Object *object, DBusMessage *msg) _process_queue_start(ed); - end: - reply = dbus_message_new_method_return(msg); - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &id); +end: + reply = edbus_message_method_return_new(msg); + edbus_message_arguments_set(reply, "i", id); return reply; } -DBusMessage * -_ethumb_dbus_queue_remove_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_queue_remove_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { - DBusMessage *reply; - DBusMessageIter iter; - dbus_int32_t id; + EDBus_Message *reply; + int id; Ethumbd_Object_Data *odata; Ethumbd_Object *eobject; Ethumbd_Request *request; Ethumbd *ed; - dbus_bool_t r = 0; + Eina_Bool r = EINA_FALSE; Eina_List *l; - dbus_message_iter_init(msg, &iter); - dbus_message_iter_get_basic(&iter, &id); - - odata = e_dbus_object_data_get(object); + if (!edbus_message_arguments_get(msg, "i", &id)) + { + ERR("Error getting arguments."); + goto end; + } + odata = edbus_service_object_data_get(iface, ODATA); if (!odata) { ERR("could not get dbus_object data."); @@ -1096,7 +1083,7 @@ _ethumb_dbus_queue_remove_cb(E_DBus_Object *object, DBusMessage *msg) if (l) { - r = 1; + r = EINA_TRUE; eina_stringshare_del(request->file); eina_stringshare_del(request->key); eina_stringshare_del(request->thumb); @@ -1109,22 +1096,20 @@ _ethumb_dbus_queue_remove_cb(E_DBus_Object *object, DBusMessage *msg) } end: - reply = dbus_message_new_method_return(msg); - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &r); + reply = edbus_message_method_return_new(msg); + edbus_message_arguments_set(reply, "b", r); return reply; } -DBusMessage * -_ethumb_dbus_queue_clear_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_queue_clear_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { - DBusMessage *reply; Ethumbd_Object_Data *odata; Ethumbd_Object *eobject; Ethumbd *ed; Eina_List *l; - odata = e_dbus_object_data_get(object); + odata = edbus_service_object_data_get(iface, ODATA); if (!odata) { ERR("could not get dbus_object data."); @@ -1148,22 +1133,19 @@ _ethumb_dbus_queue_clear_cb(E_DBus_Object *object, DBusMessage *msg) eobject->nqueue = 0; end: - reply = dbus_message_new_method_return(msg); - return reply; + return edbus_message_method_return_new(msg); } -DBusMessage * -_ethumb_dbus_delete_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_delete_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { - DBusMessage *reply; - DBusMessageIter iter; + EDBus_Message *reply; Ethumbd_Object_Data *odata; Ethumbd *ed; - dbus_message_iter_init(msg, &iter); - reply = dbus_message_new_method_return(msg); + reply = edbus_message_method_return_new(msg); - odata = e_dbus_object_data_get(object); + odata = edbus_service_object_data_get(iface, ODATA); if (!odata) { ERR("could not get dbus_object data for del_cb."); @@ -1177,19 +1159,16 @@ _ethumb_dbus_delete_cb(E_DBus_Object *object, DBusMessage *msg) } static int -_ethumb_dbus_fdo_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_fdo_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t fdo; + int fdo; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &fdo)) { ERR("invalid param for fdo_set."); return 0; } - dbus_message_iter_get_basic(iter, &fdo); DBG("setting fdo to: %d", fdo); request->setup.flags.fdo = 1; request->setup.fdo = fdo; @@ -1198,23 +1177,18 @@ _ethumb_dbus_fdo_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, } static int -_ethumb_dbus_size_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_size_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - DBusMessageIter oiter; - int type; - dbus_int32_t w, h; + EDBus_Message_Iter *st; + int w, h; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_STRUCT) + if (!edbus_message_iter_arguments_get(variant, "(ii)", &st)) { ERR("invalid param for size_set."); return 0; } - dbus_message_iter_recurse(iter, &oiter); - dbus_message_iter_get_basic(&oiter, &w); - dbus_message_iter_next(&oiter); - dbus_message_iter_get_basic(&oiter, &h); + edbus_message_iter_arguments_get(st, "ii", &w, &h); DBG("setting size to: %dx%d", w, h); request->setup.flags.size = 1; request->setup.tw = w; @@ -1224,19 +1198,16 @@ _ethumb_dbus_size_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, } static int -_ethumb_dbus_format_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_format_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t format; + int format; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &format)) { ERR("invalid param for format_set."); return 0; } - dbus_message_iter_get_basic(iter, &format); DBG("setting format to: %d", format); request->setup.flags.format = 1; request->setup.format = format; @@ -1245,19 +1216,16 @@ _ethumb_dbus_format_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *ite } static int -_ethumb_dbus_aspect_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_aspect_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t aspect; + int aspect; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &aspect)) { ERR("invalid param for aspect_set."); return 0; } - dbus_message_iter_get_basic(iter, &aspect); DBG("setting aspect to: %d", aspect); request->setup.flags.aspect = 1; request->setup.aspect = aspect; @@ -1266,19 +1234,16 @@ _ethumb_dbus_aspect_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *ite } static int -_ethumb_dbus_orientation_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_orientation_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t orientation; + int orientation; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &orientation)) { ERR("invalid param for orientation_set."); return 0; } - dbus_message_iter_get_basic(iter, &orientation); DBG("setting orientation to: %d", orientation); request->setup.flags.orientation = 1; request->setup.orientation = orientation; @@ -1287,23 +1252,18 @@ _ethumb_dbus_orientation_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter } static int -_ethumb_dbus_crop_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_crop_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - DBusMessageIter oiter; - int type; + EDBus_Message_Iter *st; double x, y; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_STRUCT) + if (!edbus_message_iter_arguments_get(variant, "(dd)", &st)) { ERR("invalid param for crop_set."); return 0; } - dbus_message_iter_recurse(iter, &oiter); - dbus_message_iter_get_basic(&oiter, &x); - dbus_message_iter_next(&oiter); - dbus_message_iter_get_basic(&oiter, &y); + edbus_message_iter_arguments_get(st, "dd", &x, &y); DBG("setting crop to: %3.2f,%3.2f", x, y); request->setup.flags.crop = 1; request->setup.cx = x; @@ -1313,19 +1273,16 @@ _ethumb_dbus_crop_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, } static int -_ethumb_dbus_quality_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_quality_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t quality; + int quality; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &quality)) { ERR("invalid param for quality_set."); return 0; } - dbus_message_iter_get_basic(iter, &quality); DBG("setting quality to: %d", quality); request->setup.flags.quality = 1; request->setup.quality = quality; @@ -1335,19 +1292,16 @@ _ethumb_dbus_quality_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *it static int -_ethumb_dbus_compress_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_compress_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; - dbus_int32_t compress; + int compress; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_INT32) + if (!edbus_message_iter_arguments_get(variant, "i", &compress)) { ERR("invalid param for compress_set."); return 0; } - dbus_message_iter_get_basic(iter, &compress); DBG("setting compress to: %d", compress); request->setup.flags.compress = 1; request->setup.compress = compress; @@ -1356,25 +1310,22 @@ _ethumb_dbus_compress_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *i } static int -_ethumb_dbus_frame_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_frame_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - DBusMessageIter oiter; - int type; + EDBus_Message_Iter *_struct, *file_iter, *group_iter, *swallow_iter; const char *file, *group, *swallow; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_STRUCT) + if (!edbus_message_iter_arguments_get(variant, "(ayayay)", &_struct)) { ERR("invalid param for frame_set."); return 0; } - dbus_message_iter_recurse(iter, &oiter); - file = _ethumb_dbus_get_bytearray(&oiter); - dbus_message_iter_next(&oiter); - group = _ethumb_dbus_get_bytearray(&oiter); - dbus_message_iter_next(&oiter); - swallow = _ethumb_dbus_get_bytearray(&oiter); + edbus_message_iter_arguments_get(_struct, "ayayay", &file_iter, &group_iter, &swallow_iter); + + file = _ethumb_dbus_get_bytearray(file_iter); + group = _ethumb_dbus_get_bytearray(group_iter); + swallow = _ethumb_dbus_get_bytearray(swallow_iter); DBG("setting frame to \"%s:%s:%s\"", file, group, swallow); request->setup.flags.frame = 1; request->setup.theme_file = eina_stringshare_add(file); @@ -1385,19 +1336,18 @@ _ethumb_dbus_frame_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter } static int -_ethumb_dbus_directory_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_directory_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; const char *directory; + EDBus_Message_Iter *array; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_ARRAY) + if (!edbus_message_iter_arguments_get(variant, "ay", &array)) { ERR("invalid param for dir_path_set."); return 0; } - directory = _ethumb_dbus_get_bytearray(iter); + directory = _ethumb_dbus_get_bytearray(array); DBG("setting directory to: %s", directory); request->setup.flags.directory = 1; request->setup.directory = eina_stringshare_add(directory); @@ -1406,19 +1356,18 @@ _ethumb_dbus_directory_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter * } static int -_ethumb_dbus_category_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_category_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; const char *category; + EDBus_Message_Iter *array; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_ARRAY) + if (!edbus_message_iter_arguments_get(variant, "ay", &array)) { ERR("invalid param for category."); return 0; } - category = _ethumb_dbus_get_bytearray(iter); + category = _ethumb_dbus_get_bytearray(array); DBG("setting category to: %s", category); request->setup.flags.category = 1; request->setup.category = eina_stringshare_add(category); @@ -1427,19 +1376,16 @@ _ethumb_dbus_category_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *i } static int -_ethumb_dbus_video_time_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_video_time_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; double video_time; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_DOUBLE) + if (!edbus_message_iter_arguments_get(variant, "d", &video_time)) { ERR("invalid param for video_time_set."); return 0; } - dbus_message_iter_get_basic(iter, &video_time); DBG("setting video_time to: %3.2f", video_time); request->setup.flags.video_time = 1; request->setup.video_time = video_time; @@ -1448,19 +1394,16 @@ _ethumb_dbus_video_time_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter } static int -_ethumb_dbus_video_start_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_video_start_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; double video_start; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_DOUBLE) + if (!edbus_message_iter_arguments_get(variant, "d", &video_start)) { ERR("invalid param for video_start_set."); return 0; } - dbus_message_iter_get_basic(iter, &video_start); DBG("setting video_start to: %3.2f", video_start); request->setup.flags.video_start = 1; request->setup.video_start = video_start; @@ -1469,19 +1412,15 @@ _ethumb_dbus_video_start_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter } static int -_ethumb_dbus_video_interval_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_video_interval_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; double video_interval; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_DOUBLE) + if (!edbus_message_iter_arguments_get(variant, "d", &video_interval)) { - ERR("invalid param for video_interval_set."); - return 0; + ERR("invalid param for video_interval_set."); + return 0; } - - dbus_message_iter_get_basic(iter, &video_interval); DBG("setting video_interval to: %3.2f", video_interval); request->setup.flags.video_interval = 1; request->setup.video_interval = video_interval; @@ -1490,19 +1429,16 @@ _ethumb_dbus_video_interval_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageI } static int -_ethumb_dbus_video_ntimes_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_video_ntimes_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; unsigned int video_ntimes; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_UINT32) + if (!edbus_message_iter_arguments_get(variant, "u", &video_ntimes)) { ERR("invalid param for video_ntimes_set."); return 0; } - dbus_message_iter_get_basic(iter, &video_ntimes); DBG("setting video_ntimes to: %3.2d", video_ntimes); request->setup.flags.video_ntimes = 1; request->setup.video_ntimes = video_ntimes; @@ -1511,19 +1447,16 @@ _ethumb_dbus_video_ntimes_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIte } static int -_ethumb_dbus_video_fps_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_video_fps_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; unsigned int video_fps; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_UINT32) + if (!edbus_message_iter_arguments_get(variant, "u", &video_fps)) { ERR("invalid param for video_fps_set."); return 0; } - dbus_message_iter_get_basic(iter, &video_fps); DBG("setting video_fps to: %3.2d", video_fps); request->setup.flags.video_fps = 1; request->setup.video_fps = video_fps; @@ -1532,19 +1465,16 @@ _ethumb_dbus_video_fps_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter * } static int -_ethumb_dbus_document_page_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_document_page_set(Ethumbd_Object *eobject __UNUSED__, EDBus_Message_Iter *variant, Ethumbd_Request *request) { - int type; unsigned int document_page; - type = dbus_message_iter_get_arg_type(iter); - if (type != DBUS_TYPE_UINT32) + if (!edbus_message_iter_arguments_get(variant, "u", &document_page)) { ERR("invalid param for document_page_set."); return 0; } - dbus_message_iter_get_basic(iter, &document_page); DBG("setting document_page to: %d", document_page); request->setup.flags.document_page = 1; request->setup.document_page = document_page; @@ -1555,7 +1485,7 @@ _ethumb_dbus_document_page_set(Ethumbd_Object *eobject __UNUSED__, DBusMessageIt static struct { const char *option; - int (*setup_func)(Ethumbd_Object *eobject, DBusMessageIter *iter, Ethumbd_Request *request); + int (*setup_func)(Ethumbd_Object *eobject, EDBus_Message_Iter *variant, Ethumbd_Request *request); } _option_cbs[] = { {"fdo", _ethumb_dbus_fdo_set}, {"size", _ethumb_dbus_size_set}, @@ -1578,15 +1508,13 @@ static struct }; static int -_ethumb_dbus_ethumb_setup_parse_element(Ethumbd_Object *eobject, DBusMessageIter *iter, Ethumbd_Request *request) +_ethumb_dbus_ethumb_setup_parse_element(Ethumbd_Object *eobject, EDBus_Message_Iter *data, Ethumbd_Request *request) { - DBusMessageIter viter, diter; + EDBus_Message_Iter *variant; const char *option; int i, r; - dbus_message_iter_recurse(iter, &diter); - dbus_message_iter_get_basic(&diter, &option); - dbus_message_iter_next(&diter); + edbus_message_iter_arguments_get(data, "sv", &option, &variant); r = 0; for (i = 0; _option_cbs[i].option; i++) @@ -1602,30 +1530,29 @@ _ethumb_dbus_ethumb_setup_parse_element(Ethumbd_Object *eobject, DBusMessageIter return 0; } - dbus_message_iter_recurse(&diter, &viter); - return _option_cbs[i].setup_func(eobject, &viter, request); + return _option_cbs[i].setup_func(eobject, variant, request); } -DBusMessage * -_ethumb_dbus_ethumb_setup_cb(E_DBus_Object *object, DBusMessage *msg) +static EDBus_Message * +_ethumb_dbus_ethumb_setup_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg) { - DBusMessage *reply; - DBusMessageIter iter, aiter; + EDBus_Message *reply; Ethumbd_Object_Data *odata; Ethumbd *ed; Ethumbd_Object *eobject; Ethumbd_Request *request; - dbus_bool_t r = 0; + Eina_Bool r = EINA_FALSE; int atype; + EDBus_Message_Iter *array; + EDBus_Message_Iter *data; - dbus_message_iter_init(msg, &iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) + if (!edbus_message_arguments_get(msg, "a{sv}", &array)) { - ERR("wrong parameters."); - goto end; + ERR("could not get dbus_object data for setup_cb."); + goto end; } - odata = e_dbus_object_data_get(object); + odata = edbus_service_object_data_get(iface, ODATA); if (!odata) { ERR("could not get dbus_object data for setup_cb."); @@ -1637,146 +1564,75 @@ _ethumb_dbus_ethumb_setup_cb(E_DBus_Object *object, DBusMessage *msg) request = calloc(1, sizeof(*request)); request->id = -1; - dbus_message_iter_recurse(&iter, &aiter); - atype = dbus_message_iter_get_arg_type(&aiter); - r = 1; - while (atype != DBUS_TYPE_INVALID) + r = EINA_TRUE; + while (edbus_message_iter_get_and_next(array, 'r', &data) && r) { - if (!_ethumb_dbus_ethumb_setup_parse_element(eobject, &aiter, request)) - r = 0; - dbus_message_iter_next(&aiter); - atype = dbus_message_iter_get_arg_type(&aiter); + if (!_ethumb_dbus_ethumb_setup_parse_element(eobject, data, request)); + r = EINA_FALSE; } eobject->queue = eina_list_append(eobject->queue, request); eobject->nqueue++; ed->queue.nqueue++; - end: - reply = dbus_message_new_method_return(msg); - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &r); - +end: + reply = edbus_message_method_return_new(msg); + edbus_message_arguments_set(reply, "b", r); return reply; } static void _ethumb_dbus_generated_signal(Ethumbd *ed, int *id, const char *thumb_path, const char *thumb_key, Eina_Bool success) { - DBusMessage *sig; + EDBus_Message *sig; int current; const char *opath; - DBusMessageIter iter; - dbus_bool_t value; - dbus_int32_t id32; + EDBus_Message_Iter *iter, *iter_path, *iter_key; + int id32; - value = success; id32 = *id; current = ed->queue.current; opath = ed->queue.table[current].path; - sig = dbus_message_new_signal - (opath, _ethumb_dbus_objects_interface, "generated"); + sig = edbus_message_signal_new(opath, _ethumb_dbus_objects_interface, + "generated"); - dbus_message_iter_init_append(sig, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &id32); - _ethumb_dbus_append_bytearray(&iter, thumb_path); - _ethumb_dbus_append_bytearray(&iter, thumb_key); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &value); + iter = edbus_message_iter_get(sig); + edbus_message_iter_arguments_set(iter, "iay", id32, &iter_path); + _ethumb_dbus_append_bytearray(iter, iter_path, thumb_path); + edbus_message_iter_arguments_set(iter, "ay", &iter_key); + _ethumb_dbus_append_bytearray(iter, iter_key, thumb_key); + edbus_message_iter_arguments_set(iter, "b", success); - e_dbus_message_send(ed->conn, sig, NULL, -1, NULL); - dbus_message_unref(sig); + edbus_connection_send(ed->conn, sig, NULL, NULL, -1); + edbus_message_unref(sig); } -static struct _Ethumb_DBus_Method_Table _ethumb_dbus_objects_methods[] = { - {"queue_add", "iayayayay", "i", _ethumb_dbus_queue_add_cb}, - {"queue_remove", "i", "b", _ethumb_dbus_queue_remove_cb}, - {"clear_queue", "", "", _ethumb_dbus_queue_clear_cb}, - {"ethumb_setup", "a{sv}", "b", _ethumb_dbus_ethumb_setup_cb}, - {"delete", "", "", _ethumb_dbus_delete_cb}, - {NULL, NULL, NULL, NULL} +static const EDBus_Service_Interface_Desc server_desc = { + _ethumb_dbus_interface, _ethumb_dbus_methods }; -static struct _Ethumb_DBus_Signal_Table _ethumb_dbus_objects_signals[] = { - {"generated", "iayayb"}, - {NULL, NULL} -}; - -static int -_ethumb_dbus_interface_elements_add(E_DBus_Interface *iface, struct _Ethumb_DBus_Method_Table *mtable, struct _Ethumb_DBus_Signal_Table *stable) -{ - int i = -1; - while (mtable && mtable[++i].name) - if (!e_dbus_interface_method_add(iface, - mtable[i].name, - mtable[i].signature, - mtable[i].reply, - mtable[i].function)) - return 0; - - i = -1; - while (stable && stable[++i].name) - if (!e_dbus_interface_signal_add(iface, - stable[i].name, - stable[i].signature)) - return 0; - return 1; -} - static void -_ethumb_dbus_request_name_cb(void *data, DBusMessage *msg __UNUSED__, DBusError *err) +_ethumb_dbus_request_name_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) { - E_DBus_Object *dbus_object; + EDBus_Service_Interface *iface; + const char *errname, *errmsg; Ethumbd *ed = data; int r; - if (dbus_error_is_set(err)) + if (edbus_message_error_get(msg, &errname, &errmsg)) { - ERR("request name error: %s", err->message); - dbus_error_free(err); - e_dbus_connection_close(ed->conn); - return; + ERR("request name error: %s %s", errname, errmsg); + edbus_connection_unref(ed->conn); + return; } - dbus_object = e_dbus_object_add(ed->conn, _ethumb_dbus_path, ed); - if (!dbus_object) - return; - ed->dbus_obj = dbus_object; - ed->eiface = e_dbus_interface_new(_ethumb_dbus_interface); - if (!ed->eiface) - { - ERR("could not create interface."); - return; - } - r = _ethumb_dbus_interface_elements_add(ed->eiface, - _ethumb_dbus_methods, NULL); - if (!r) - { - ERR("could not add methods to the interface."); - e_dbus_interface_unref(ed->eiface); - return; - } - e_dbus_object_interface_attach(dbus_object, ed->eiface); + iface = edbus_service_interface_register(ed->conn, _ethumb_dbus_path, + &server_desc); + EINA_SAFETY_ON_NULL_RETURN(iface); - ed->objects_iface = e_dbus_interface_new(_ethumb_dbus_objects_interface); - if (!ed->objects_iface) - { - ERR("could not create interface."); - return; - } - - r = _ethumb_dbus_interface_elements_add(ed->objects_iface, - _ethumb_dbus_objects_methods, - _ethumb_dbus_objects_signals); - if (!r) - { - ERR("ERROR: could not setup objects interface methods."); - e_dbus_interface_unref(ed->objects_iface); - return; - } - - _ethumb_dbus_add_name_owner_changed_cb(ed); + edbus_service_object_data_set(iface, DAEMON, ed); _ethumbd_timeout_start(ed); } @@ -1784,9 +1640,8 @@ _ethumb_dbus_request_name_cb(void *data, DBusMessage *msg __UNUSED__, DBusError static int _ethumb_dbus_setup(Ethumbd *ed) { - e_dbus_request_name - (ed->conn, _ethumb_dbus_bus_name, 0, _ethumb_dbus_request_name_cb, ed); - + edbus_name_request(ed->conn, _ethumb_dbus_bus_name, 0, + _ethumb_dbus_request_name_cb, ed); return 1; } @@ -1795,10 +1650,7 @@ _ethumb_dbus_finish(Ethumbd *ed) { _process_queue_stop(ed); _ethumb_table_clear(ed); - e_dbus_signal_handler_del(ed->conn, ed->name_owner_changed_handler); - e_dbus_interface_unref(ed->objects_iface); - e_dbus_interface_unref(ed->eiface); - e_dbus_object_free(ed->dbus_obj); + edbus_connection_unref(ed->conn); free(ed->queue.table); free(ed->queue.list); } @@ -1866,9 +1718,9 @@ main(int argc, char *argv[]) goto finish; } - if (!e_dbus_init()) + if (!edbus_init()) { - ERR("could not init e_dbus."); + ERR("could not init edbus."); exit_value = -1; goto finish; } @@ -1893,7 +1745,7 @@ main(int argc, char *argv[]) if (quit_option) goto finish; - ed.conn = e_dbus_bus_get(DBUS_BUS_SESSION); + ed.conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); if (!ed.conn) { ERR("could not connect to session bus."); @@ -1905,7 +1757,7 @@ main(int argc, char *argv[]) if (!_ethumb_dbus_setup(&ed)) { - e_dbus_connection_close(ed.conn); + edbus_connection_unref(ed.conn); ERR("could not setup dbus connection."); exit_value = -5; goto finish_edbus; @@ -1921,7 +1773,7 @@ main(int argc, char *argv[]) _log_domain = -1; } - e_dbus_shutdown(); + edbus_shutdown(); finish: if (ed.slave.exe) ecore_exe_quit(ed.slave.exe); diff --git a/legacy/ethumb/src/bin/ethumbd_client.c b/legacy/ethumb/src/bin/ethumbd_client.c index 54b02c7e90..1dcdf111ed 100644 --- a/legacy/ethumb/src/bin/ethumbd_client.c +++ b/legacy/ethumb/src/bin/ethumbd_client.c @@ -232,7 +232,7 @@ main(int argc, char *argv[]) { Ethumb_Client *c; Eina_Bool quit_option = 0; - const char *format_str = NULL, *aspect_str; + const char *format_str = NULL, *aspect_str = NULL; struct options opts = { {-1, -1, -1, -1}, 0, 0, diff --git a/legacy/ethumb/src/lib/client/Ethumb_Client.h b/legacy/ethumb/src/lib/client/Ethumb_Client.h index 81105aacaf..47fe5ee60f 100644 --- a/legacy/ethumb/src/lib/client/Ethumb_Client.h +++ b/legacy/ethumb/src/lib/client/Ethumb_Client.h @@ -127,7 +127,7 @@ typedef void (*Ethumb_Client_Generate_Cancel_Cb)(void *data, Eina_Bool success); EAPI int ethumb_client_init(void); EAPI int ethumb_client_shutdown(void); -EAPI Ethumb_Client * ethumb_client_connect(Ethumb_Client_Connect_Cb connect_cb, const void *data, Eina_Free_Cb free_data); +EAPI Ethumb_Client *ethumb_client_connect(Ethumb_Client_Connect_Cb connect_cb, const void *data, Eina_Free_Cb free_data); EAPI void ethumb_client_disconnect(Ethumb_Client *client); EAPI void ethumb_client_on_server_die_callback_set(Ethumb_Client *client, Ethumb_Client_Die_Cb server_die_cb, const void *data, Eina_Free_Cb free_data); diff --git a/legacy/ethumb/src/lib/client/ethumb_client.c b/legacy/ethumb/src/lib/client/ethumb_client.c index ee17507cd1..0efcb1beeb 100644 --- a/legacy/ethumb/src/lib/client/ethumb_client.c +++ b/legacy/ethumb/src/lib/client/ethumb_client.c @@ -77,7 +77,7 @@ #include #include -#include +#include #include #include @@ -100,15 +100,8 @@ struct _Ethumb_Client { Ethumb *ethumb; int id_count; - Ethumb *old_ethumb_conf; - E_DBus_Connection *conn; - E_DBus_Signal_Handler *name_owner_changed_handler; - E_DBus_Signal_Handler *generated_signal; - DBusPendingCall *pending_get_name_owner; - DBusPendingCall *pending_start_service_by_name; - const char *unique_name; - DBusPendingCall *pending_new; + EDBus_Connection *conn; struct { Ethumb_Client_Connect_Cb cb; @@ -118,25 +111,21 @@ struct _Ethumb_Client Eina_List *pending_add; Eina_List *pending_remove; Eina_List *pending_gen; - DBusPendingCall *pending_clear; - DBusPendingCall *pending_setup; struct { Ethumb_Client_Die_Cb cb; void *data; Eina_Free_Cb free_data; } die; - const char *object_path; - + EDBus_Proxy *proxy; EINA_REFCOUNT; - Eina_Bool connected : 1; Eina_Bool server_started : 1; }; struct _ethumb_pending_add { - dbus_int32_t id; + int32_t id; const char *file; const char *key; const char *thumb; @@ -144,23 +133,22 @@ struct _ethumb_pending_add Ethumb_Client_Generate_Cb generated_cb; void *data; Eina_Free_Cb free_data; - DBusPendingCall *pending_call; + EDBus_Pending *pending_call; Ethumb_Client *client; }; struct _ethumb_pending_remove { - dbus_int32_t id; + int32_t id; Ethumb_Client_Generate_Cancel_Cb cancel_cb; void *data; Eina_Free_Cb free_data; - DBusPendingCall *pending_call; Ethumb_Client *client; }; struct _ethumb_pending_gen { - dbus_int32_t id; + int32_t id; const char *file; const char *key; const char *thumb; @@ -203,63 +191,9 @@ static const char fdo_path[] = "/org/freedesktop/DBus"; static int _initcount = 0; static Eina_Hash *_exists_request = NULL; -static void _ethumb_client_generated_cb(void *data, DBusMessage *msg); -static void _ethumb_client_get_name_owner(void *data, DBusMessage *msg, DBusError *err); - -static inline bool -__dbus_callback_check_and_init(const char *file, int line, const char *function, DBusMessage *msg, DBusMessageIter *itr, DBusError *err) -{ - if (!msg) - { - ERR("%s:%d:%s() callback without message arguments!", - file, line, function); - - if (err) - ERR("%s:%d:%s() an error was reported by server: " - "name=\"%s\", message=\"%s\"", - file, line, function, err->name, err->message); - - return 0; - } - - if (!dbus_message_iter_init(msg, itr)) - { - ERR("%s:%d:%s() could not init iterator.", - file, line, function); - return 0; - } - - return 1; -} - -#define _dbus_callback_check_and_init(msg, itr, err) \ - __dbus_callback_check_and_init(__FILE__, __LINE__, __FUNCTION__, \ - msg, itr, err) - -static inline bool -__dbus_iter_type_check(int type, int expected, const char *expected_name) -{ - if (type == expected) - return 1; - - ERR("expected type %s (%c) but got %c instead!", - expected_name, expected, type); - - return 0; -} - -#define _dbus_iter_type_check(t, e) __dbus_iter_type_check(t, e, #e) - -#define CHECK_NULL_RETURN(ptr, ...) \ - do \ - { \ - if ((ptr) == NULL) \ - { \ - CRITICAL("%s == NULL!", #ptr); \ - return __VA_ARGS__; \ - } \ - } \ - while (0) +static void _ethumb_client_generated_cb(void *data, const EDBus_Message *msg); +static void _ethumb_client_call_new(Ethumb_Client *client); +static void _ethumb_client_name_owner_changed(void *context, const char *bus, const char *old_id, const char *new_id); static void _ethumb_client_free(Ethumb_Client *client) @@ -272,15 +206,7 @@ _ethumb_client_free(Ethumb_Client *client) EINA_LIST_FREE(client->pending_add, data) { struct _ethumb_pending_add *pending = data; - eina_stringshare_del(pending->file); - eina_stringshare_del(pending->key); - eina_stringshare_del(pending->thumb); - eina_stringshare_del(pending->thumb_key); - dbus_pending_call_cancel(pending->pending_call); - dbus_pending_call_unref(pending->pending_call); - if (pending->free_data) - pending->free_data(pending->data); - free(pending); + edbus_pending_cancel(pending->pending_call); } EINA_LIST_FREE(client->pending_gen, data) @@ -298,44 +224,21 @@ _ethumb_client_free(Ethumb_Client *client) EINA_LIST_FREE(client->pending_remove, data) { struct _ethumb_pending_remove *pending = data; - dbus_pending_call_cancel(pending->pending_call); - dbus_pending_call_unref(pending->pending_call); if (pending->free_data) pending->free_data(pending->data); free(pending); } - if (client->pending_clear) - { - dbus_pending_call_cancel(client->pending_clear); - dbus_pending_call_unref(client->pending_clear); - } - end_connection: - if (client->object_path) - eina_stringshare_del(client->object_path); - - if (client->pending_new) - dbus_pending_call_cancel(client->pending_new); - - if (client->unique_name) - eina_stringshare_del(client->unique_name); - - if (client->pending_get_name_owner) - dbus_pending_call_cancel(client->pending_get_name_owner); - - if (client->pending_start_service_by_name) - dbus_pending_call_cancel(client->pending_start_service_by_name); - if (client->old_ethumb_conf) ethumb_free(client->old_ethumb_conf); ethumb_free(client->ethumb); - e_dbus_signal_handler_del(client->conn, client->name_owner_changed_handler); - if (client->connected) - e_dbus_signal_handler_del(client->conn, client->generated_signal); - e_dbus_connection_close(client->conn); + edbus_name_owner_changed_callback_del(client->conn, _ethumb_dbus_bus_name, + _ethumb_client_name_owner_changed, + client); + edbus_connection_unref(client->conn); if (client->connect.free_data) client->connect.free_data(client->connect.data); @@ -360,56 +263,32 @@ _ethumb_async_delete(void *data) } static void -_ethumb_client_name_owner_changed(void *data, DBusMessage *msg) +_ethumb_client_name_owner_changed(void *context, const char *bus, const char *old_id, const char *new_id) { - DBusError err; - const char *name, *from, *to; - Ethumb_Client *client = data; - - dbus_error_init(&err); - if (!dbus_message_get_args(msg, &err, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_STRING, &from, - DBUS_TYPE_STRING, &to, - DBUS_TYPE_INVALID)) + Ethumb_Client *client = context; + DBG("NameOwnerChanged from=[%s] to=[%s]", old_id, new_id); + if (new_id[0]) { - ERR("could not get NameOwnerChanged arguments: %s: %s", - err.name, err.message); - dbus_error_free(&err); + if (client->connected) + return; + + client->connected = EINA_TRUE; + _ethumb_client_call_new(client); return; } - - if (!from || !name) - return; - if (strcmp(name, _ethumb_dbus_bus_name) != 0) - return; - - DBG("NameOwnerChanged from=[%s] to=[%s]", from, to); - - if (from[0] != '\0' && to[0] == '\0') + ERR("server exit!!!"); + client->connected = EINA_FALSE; + if (client->die.cb) { - DBG("exit ethumbd at %s", from); - if (client->unique_name && strcmp(client->unique_name, from) != 0) - WRN("%s was not the known name %s, ignored.", - from, client->unique_name); - else if (client->unique_name) - { - ERR("server exit!!!"); - if (client->die.cb) - { - client->die.cb(client->die.data, client); - client->die.cb = NULL; - } - if (client->die.free_data) - { - client->die.free_data(client->die.data); - client->die.free_data = NULL; - client->die.data = NULL; - } - } + client->die.cb(client->die.data, client); + client->die.cb = NULL; + } + if (client->die.free_data) + { + client->die.free_data(client->die.data); + client->die.free_data = NULL; + client->die.data = NULL; } - else - DBG("unknown change from %s to %s", from, to); } static void @@ -432,163 +311,42 @@ _ethumb_client_report_connect(Ethumb_Client *client, Eina_Bool success) } static void -_ethumb_client_new_cb(void *data, DBusMessage *msg, DBusError *error) +_ethumb_client_new_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) { - DBusMessageIter iter; + const char *errname, *errmsg; const char *opath; - int t; Ethumb_Client *client = data; + EDBus_Object *obj; - client->pending_new = NULL; + if (edbus_message_error_get(msg, &errname, &errmsg)) + { + ERR("Error: %s %s", errname, errmsg); + return; + } - if (!_dbus_callback_check_and_init(msg, &iter, error)) - goto end_error; - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_OBJECT_PATH)) - goto end_error; - - dbus_message_iter_get_basic(&iter, &opath); - if (opath[0] == '\0') - goto end_error; - - client->object_path = eina_stringshare_add(opath); - - client->generated_signal = e_dbus_signal_handler_add( - client->conn, _ethumb_dbus_bus_name, opath, - _ethumb_dbus_objects_interface, "generated", - _ethumb_client_generated_cb, client); + if (!edbus_message_arguments_get(msg, "o", &opath)) + { + ERR("Error: could not get entry contents"); + _ethumb_client_report_connect(client, 0); + return; + } + obj = edbus_object_get(client->conn, _ethumb_dbus_bus_name, opath); + client->proxy = edbus_proxy_get(obj, _ethumb_dbus_objects_interface); + edbus_proxy_signal_handler_add(client->proxy, "generated", + _ethumb_client_generated_cb, client); _ethumb_client_report_connect(client, 1); - return; - -end_error: - _ethumb_client_report_connect(client, 0); } static void _ethumb_client_call_new(Ethumb_Client *client) { - DBusMessage *msg; - - msg = dbus_message_new_method_call(_ethumb_dbus_bus_name, _ethumb_dbus_path, - _ethumb_dbus_interface, "new"); - client->pending_new = e_dbus_message_send(client->conn, msg, - _ethumb_client_new_cb, -1, - client); - dbus_message_unref(msg); -} - -static void -_ethumb_client_start_server_cb(void *data, DBusMessage *msg, DBusError *err) -{ - Ethumb_Client *client = data; - DBusMessageIter iter; - dbus_uint32_t ret; - int t; - - client->pending_start_service_by_name = NULL; - - if (!_dbus_callback_check_and_init(msg, &iter, err)) - goto error; - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_UINT32)) - goto error; - - dbus_message_iter_get_basic(&iter, &ret); - if ((ret != 1) && (ret != 2)) - { - ERR("Error starting Ethumbd DBus service by its name: retcode %u", - ret); - goto error; - } - - client->server_started = 1; - DBG("Ethumbd DBus service started successfully (%d), now request its name", - ret); - - if (client->pending_get_name_owner) - { - DBG("already requesting name owner, cancel and try again"); - dbus_pending_call_cancel(client->pending_get_name_owner); - } - - client->pending_get_name_owner = e_dbus_get_name_owner - (client->conn, _ethumb_dbus_bus_name, _ethumb_client_get_name_owner, - client); - if (!client->pending_get_name_owner) - { - ERR("could not create a get_name_owner request."); - goto error; - } - - return; - -error: - ERR("failed to start Ethumbd DBus service by its name."); - _ethumb_client_report_connect(client, 0); -} - -static void -_ethumb_client_start_server(Ethumb_Client *client) -{ - if (client->pending_start_service_by_name) - { - DBG("already pending start service by name."); - return; - } - - client->server_started = 0; - client->pending_start_service_by_name = e_dbus_start_service_by_name - (client->conn, _ethumb_dbus_bus_name, 0, _ethumb_client_start_server_cb, - client); - if (!client->pending_start_service_by_name) - { - ERR("could not start service by name!"); - _ethumb_client_report_connect(client, 0); - } -} - -static void -_ethumb_client_get_name_owner(void *data, DBusMessage *msg, DBusError *err) -{ - DBusMessageIter iter; - const char *uid; - Ethumb_Client *client = data; - int t; - - client->pending_get_name_owner = NULL; - - if (dbus_error_is_set(err) && (!client->server_started)) - { - DBG("could not find server (%s), try to start it...", err->message); - _ethumb_client_start_server(client); - return; - } - - if (!_dbus_callback_check_and_init(msg, &iter, err)) - goto error; - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_STRING)) - goto error; - - dbus_message_iter_get_basic(&iter, &uid); - if (!uid) - { - ERR("no name owner!"); - goto error; - } - - DBG("unique name = %s", uid); - client->unique_name = eina_stringshare_add(uid); - - _ethumb_client_call_new(client); - client->connected = 1; - return; - -error: - _ethumb_client_report_connect(client, 0); + EDBus_Message *msg; + msg = edbus_message_method_call_new(_ethumb_dbus_bus_name, + _ethumb_dbus_path, + _ethumb_dbus_interface, "new"); + edbus_connection_send(client->conn, msg, _ethumb_client_new_cb, client, -1); + edbus_message_unref(msg); } static void @@ -670,7 +428,7 @@ ethumb_client_init(void) } ethumb_init(); - e_dbus_init(); + edbus_init(); _exists_request = eina_hash_stringshared_new(_ethumb_async_delete); @@ -704,7 +462,7 @@ ethumb_client_shutdown(void) eina_hash_free(_exists_request); _exists_request = NULL; - e_dbus_shutdown(); + edbus_shutdown(); ethumb_shutdown(); eina_log_domain_unregister(_log_dom); _log_dom = -1; @@ -776,26 +534,17 @@ ethumb_client_connect(Ethumb_Client_Connect_Cb connect_cb, const void *data, Ein goto ethumb_new_err; } - eclient->conn = e_dbus_bus_get(DBUS_BUS_SESSION); + eclient->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION); if (!eclient->conn) { ERR("could not connect to session bus."); goto connection_err; } - eclient->name_owner_changed_handler = e_dbus_signal_handler_add( - eclient->conn, fdo_bus_name, fdo_path, fdo_interface, - "NameOwnerChanged", _ethumb_client_name_owner_changed, eclient); - - eclient->pending_get_name_owner = e_dbus_get_name_owner( - eclient->conn, _ethumb_dbus_bus_name, _ethumb_client_get_name_owner, - eclient); - if (!eclient->pending_get_name_owner) - { - ERR("could not create a get_name_owner request."); - goto connection_err; - } - + edbus_name_start(eclient->conn, _ethumb_dbus_bus_name, 0, NULL, NULL); + edbus_name_owner_changed_callback_add(eclient->conn, _ethumb_dbus_bus_name, + _ethumb_client_name_owner_changed, + eclient, EINA_TRUE); EINA_REFCOUNT_INIT(eclient); return eclient; @@ -868,67 +617,76 @@ ethumb_client_on_server_die_callback_set(Ethumb_Client *client, Ethumb_Client_Di */ static void -_ethumb_client_ethumb_setup_cb(void *data, DBusMessage *msg, DBusError *error) +_ethumb_client_ethumb_setup_cb(void *data, const EDBus_Message *msg, EDBus_Pending *pending) { - DBusMessageIter iter; - int t; - dbus_bool_t result = 0; - Ethumb_Client *client = data; + const char *errname, *errmsg; + Eina_Bool result = 0; - client->pending_setup = NULL; + if (edbus_message_error_get(msg, &errname, &errmsg)) + { + ERR("Error: %s %s\n", errname, errmsg); + return; + } - if (!_dbus_callback_check_and_init(msg, &iter, error)) - return; - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_BOOLEAN)) - return; - - dbus_message_iter_get_basic(&iter, &result); + if (!edbus_message_arguments_get(msg, "b", &result)) + { + ERR("Error getting arguments"); + return; + } + EINA_SAFETY_ON_FALSE_RETURN(result); } static const char * -_ethumb_client_dbus_get_bytearray(DBusMessageIter *iter) +_ethumb_client_dbus_get_bytearray(EDBus_Message_Iter *array) { - int el_type; int length; - DBusMessageIter riter; const char *result; - el_type = dbus_message_iter_get_element_type(iter); - if (el_type != DBUS_TYPE_BYTE) - { - ERR("not an byte array element."); - return NULL; - } - - dbus_message_iter_recurse(iter, &riter); - dbus_message_iter_get_fixed_array(&riter, &result, &length); - - if (result[0] == '\0') - return NULL; - else + if (edbus_message_iter_fixed_array_get(array, 'y', &result, &length)) return eina_stringshare_add(result); + else + return NULL; } static void -_ethumb_client_dbus_append_bytearray(DBusMessageIter *iter, const char *string) +_ethumb_client_dbus_append_bytearray(EDBus_Message_Iter *parent, const char *string) { - DBusMessageIter viter; + int i, size; + EDBus_Message_Iter *array; if (!string) string = ""; - dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "y", &viter); - dbus_message_iter_append_fixed_array(&viter, DBUS_TYPE_BYTE, &string, - strlen(string) + 1); - dbus_message_iter_close_container(iter, &viter); + array = edbus_message_iter_container_new(parent, 'a', "y"); + size = strlen(string); + for (i = 0; i < size; i++) + edbus_message_iter_basic_append(array, 'y', string[i]); + edbus_message_iter_container_close(parent, array); } /** * @endcond */ +static EDBus_Message_Iter * +_setup_iterator_open(EDBus_Message_Iter *array, EDBus_Message_Iter **config, const char *key, const char *type) +{ + EDBus_Message_Iter *variant, *_struct; + edbus_message_iter_arguments_set(array, "{sv}", &_struct); + edbus_message_iter_basic_append(_struct, 's', key); + variant = edbus_message_iter_container_new(_struct, 'v', type); + + *config = _struct; + return variant; +} + +static void +_setup_iterator_close(EDBus_Message_Iter *array, EDBus_Message_Iter *config, EDBus_Message_Iter *variant) +{ + edbus_message_iter_container_close(config, variant); + edbus_message_iter_container_close(array, config); +} + /** * Send setup to server. * @@ -941,192 +699,145 @@ _ethumb_client_dbus_append_bytearray(DBusMessageIter *iter, const char *string) EAPI void ethumb_client_ethumb_setup(Ethumb_Client *client) { - DBusMessage *msg; - DBusMessageIter iter, aiter, diter, viter, vaiter; + EDBus_Message *msg; + EDBus_Message_Iter *array, *main; + EDBus_Message_Iter *config, *variant; + EDBus_Message_Iter *sub_struct; Ethumb *e = client->ethumb; const char *entry; - dbus_int32_t tw, th, format, aspect, orientation, quality, compress; + int tw, th, format, aspect, orientation, quality, compress; float cx, cy; double t; const char *theme_file, *group, *swallow; const char *directory, *category; double video_time, video_start, video_interval; - dbus_int32_t video_ntimes, video_fps, document_page; + unsigned int video_ntimes, video_fps, document_page; EINA_SAFETY_ON_NULL_RETURN(client); EINA_SAFETY_ON_FALSE_RETURN(client->connected); - msg = dbus_message_new_method_call(_ethumb_dbus_bus_name, - client->object_path, - _ethumb_dbus_objects_interface, - "ethumb_setup"); - dbus_message_iter_init_append(msg, &iter); - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &aiter); - -/** - * @cond LOCAL - */ -#define _open_variant_iter(str_entry, str_type, end_iter) \ - entry = str_entry; \ - dbus_message_iter_open_container(&aiter, DBUS_TYPE_DICT_ENTRY, NULL, &diter); \ - dbus_message_iter_append_basic(&diter, DBUS_TYPE_STRING, &entry); \ - dbus_message_iter_open_container(&diter, DBUS_TYPE_VARIANT, str_type, \ - &end_iter); - -#define _close_variant_iter(end_iter) \ - dbus_message_iter_close_container(&diter, &end_iter); \ - dbus_message_iter_close_container(&aiter, &diter); -/** - * @endcond - */ + msg = edbus_proxy_method_call_new(client->proxy, "ethumb_setup"); + main = edbus_message_iter_get(msg); + edbus_message_iter_arguments_set(main, "a{sv}", &array); /* starting array elements */ - - _open_variant_iter("size", "(ii)", viter); - dbus_message_iter_open_container(&viter, DBUS_TYPE_STRUCT, NULL, &vaiter); + variant = _setup_iterator_open(array, &config, "size", "(ii)"); + edbus_message_iter_arguments_set(variant, "(ii)", &sub_struct); ethumb_thumb_size_get(e, &tw, &th); - dbus_message_iter_append_basic(&vaiter, DBUS_TYPE_INT32, &tw); - dbus_message_iter_append_basic(&vaiter, DBUS_TYPE_INT32, &th); - dbus_message_iter_close_container(&viter, &vaiter); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(sub_struct, "ii", tw, th); + edbus_message_iter_container_close(sub_struct, variant); + _setup_iterator_close(array, config, variant); - _open_variant_iter("format", "i", viter); + variant = _setup_iterator_open(array, &config, "format", "i"); format = ethumb_thumb_format_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_INT32, &format); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "i", format); + _setup_iterator_close(array, config, variant); - _open_variant_iter("aspect", "i", viter); + variant = _setup_iterator_open(array, &config, "aspect", "i"); aspect = ethumb_thumb_aspect_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_INT32, &aspect); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "i", aspect); + _setup_iterator_close(array, config, variant); - _open_variant_iter("orientation", "i", viter); + variant = _setup_iterator_open(array, &config, "orientation", "i"); orientation = ethumb_thumb_orientation_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_INT32, &orientation); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "i", orientation); + _setup_iterator_close(array, config, variant); - _open_variant_iter("crop", "(dd)", viter); - dbus_message_iter_open_container(&viter, DBUS_TYPE_STRUCT, NULL, &vaiter); + variant = _setup_iterator_open(array, &config, "crop", "(dd)"); + edbus_message_iter_arguments_set(variant, "(dd)", &sub_struct); ethumb_thumb_crop_align_get(e, &cx, &cy); - t = cx; - dbus_message_iter_append_basic(&vaiter, DBUS_TYPE_DOUBLE, &t); - t = cy; - dbus_message_iter_append_basic(&vaiter, DBUS_TYPE_DOUBLE, &t); - dbus_message_iter_close_container(&viter, &vaiter); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(sub_struct, "dd", (double)cx, (double)cy); + edbus_message_iter_container_close(sub_struct, variant); + _setup_iterator_close(array, config, variant); - _open_variant_iter("quality", "i", viter); + variant = _setup_iterator_open(array, &config, "quality", "i"); quality = ethumb_thumb_quality_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_INT32, &quality); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "i", quality); + _setup_iterator_close(array, config, variant); - _open_variant_iter("compress", "i", viter); - compress = ethumb_thumb_compress_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_INT32, &compress); - _close_variant_iter(viter); + variant = _setup_iterator_open(array, &config, "compress", "i"); + quality = ethumb_thumb_quality_get(e); + edbus_message_iter_arguments_set(variant, "i", compress); + _setup_iterator_close(array, config, variant); - _open_variant_iter("frame", "(ayayay)", viter); - dbus_message_iter_open_container(&viter, DBUS_TYPE_STRUCT, NULL, &vaiter); + variant = _setup_iterator_open(array, &config, "frame", "(ayayay)"); + edbus_message_iter_arguments_set(variant, "(ayayay)", &sub_struct); ethumb_frame_get(e, &theme_file, &group, &swallow); - _ethumb_client_dbus_append_bytearray(&vaiter, theme_file); - _ethumb_client_dbus_append_bytearray(&vaiter, group); - _ethumb_client_dbus_append_bytearray(&vaiter, swallow); - dbus_message_iter_close_container(&viter, &vaiter); - _close_variant_iter(viter); + _ethumb_client_dbus_append_bytearray(sub_struct, theme_file); + _ethumb_client_dbus_append_bytearray(sub_struct, group); + _ethumb_client_dbus_append_bytearray(sub_struct, swallow); + _setup_iterator_close(array, config, variant); - _open_variant_iter("directory", "ay", viter); + variant = _setup_iterator_open(array, &config, "directory", "ay"); directory = ethumb_thumb_dir_path_get(e); - _ethumb_client_dbus_append_bytearray(&viter, directory); - _close_variant_iter(viter); + _ethumb_client_dbus_append_bytearray(variant, directory); + _setup_iterator_close(array, config, variant); - _open_variant_iter("category", "ay", viter); + variant = _setup_iterator_open(array, &config, "category", "ay"); category = ethumb_thumb_category_get(e); - _ethumb_client_dbus_append_bytearray(&viter, category); - _close_variant_iter(viter); + _ethumb_client_dbus_append_bytearray(variant, category); + _setup_iterator_close(array, config, variant); - _open_variant_iter("video_time", "d", viter); + variant = _setup_iterator_open(array, &config, "video_time", "d"); video_time = ethumb_video_time_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_DOUBLE, &video_time); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "d", video_time); + _setup_iterator_close(array, config, variant); - _open_variant_iter("video_start", "d", viter); + variant = _setup_iterator_open(array, &config, "video_start", "d"); video_start = ethumb_video_start_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_DOUBLE, &video_start); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "d", video_start); + _setup_iterator_close(array, config, variant); - _open_variant_iter("video_interval", "d", viter); + variant = _setup_iterator_open(array, &config, "video_interval", "d"); video_interval = ethumb_video_interval_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_DOUBLE, &video_interval); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "d", video_interval); + _setup_iterator_close(array, config, variant); - _open_variant_iter("video_ntimes", "u", viter); + variant = _setup_iterator_open(array, &config, "video_ntimes", "u"); video_ntimes = ethumb_video_ntimes_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_UINT32, &video_ntimes); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "u", video_ntimes); + _setup_iterator_close(array, config, variant); - _open_variant_iter("video_fps", "u", viter); + variant = _setup_iterator_open(array, &config, "video_fps", "u"); video_fps = ethumb_video_fps_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_UINT32, &video_fps); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "u", video_fps); + _setup_iterator_close(array, config, variant); - _open_variant_iter("document_page", "u", viter); + variant = _setup_iterator_open(array, &config, "document_page", "u"); document_page = ethumb_document_page_get(e); - dbus_message_iter_append_basic(&viter, DBUS_TYPE_UINT32, &document_page); - _close_variant_iter(viter); + edbus_message_iter_arguments_set(variant, "u", document_page); + _setup_iterator_close(array, config, variant); -#undef _open_variant_iter -#undef _close_variant_iter + edbus_message_iter_container_close(main, array); - dbus_message_iter_close_container(&iter, &aiter); - - client->pending_setup = e_dbus_message_send(client->conn, msg, - _ethumb_client_ethumb_setup_cb, - -1, client); - dbus_message_unref(msg); + edbus_proxy_send(client->proxy, msg, _ethumb_client_ethumb_setup_cb, + client, -1); + edbus_message_unref(msg); } /** * @cond LOCAL */ - static void -_ethumb_client_generated_cb(void *data, DBusMessage *msg) +_ethumb_client_generated_cb(void *data, const EDBus_Message *msg) { - DBusMessageIter iter; - dbus_int32_t id = -1; + int id = -1; + Ethumb_Client *client = data; + EDBus_Message_Iter *thumb_iter; + EDBus_Message_Iter *thumb_key_iter; + Eina_Bool success; const char *thumb = NULL; const char *thumb_key = NULL; - Ethumb_Client *client = data; - int t; - dbus_bool_t success; - Eina_List *l; int found; struct _ethumb_pending_gen *pending; + Eina_List *l; - dbus_message_iter_init(msg, &iter); - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_INT32)) - goto end; - dbus_message_iter_get_basic(&iter, &id); - dbus_message_iter_next(&iter); - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_ARRAY)) - goto end; - thumb = _ethumb_client_dbus_get_bytearray(&iter); - dbus_message_iter_next(&iter); - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_ARRAY)) - goto end; - thumb_key = _ethumb_client_dbus_get_bytearray(&iter); - dbus_message_iter_next(&iter); - - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_BOOLEAN)) - goto end; - dbus_message_iter_get_basic(&iter, &success); + if (!edbus_message_arguments_get(msg, "iayayb", &id, &thumb_iter, + &thumb_key_iter, &success)) + { + ERR("Error getting data from signal."); + return; + } found = 0; l = client->pending_gen; @@ -1143,6 +854,9 @@ _ethumb_client_generated_cb(void *data, DBusMessage *msg) if (found) { + thumb = _ethumb_client_dbus_get_bytearray(thumb_iter); + thumb_key = _ethumb_client_dbus_get_bytearray(thumb_key_iter); + client->pending_gen = eina_list_remove_list(client->pending_gen, l); if (pending->generated_cb) pending->generated_cb(pending->data, client, id, @@ -1157,32 +871,31 @@ _ethumb_client_generated_cb(void *data, DBusMessage *msg) eina_stringshare_del(pending->thumb_key); free(pending); } - -end: - if (thumb) eina_stringshare_del(thumb); - if (thumb_key) eina_stringshare_del(thumb_key); } static void -_ethumb_client_queue_add_cb(void *data, DBusMessage *msg, DBusError *error) +_ethumb_client_queue_add_cb(void *data, const EDBus_Message *msg, EDBus_Pending *edbus_pending) { - DBusMessageIter iter; - int t; - dbus_int32_t id = -1; + const char *errname, *errmsg; + int32_t id; struct _ethumb_pending_add *pending = data; struct _ethumb_pending_gen *generating; Ethumb_Client *client = pending->client; client->pending_add = eina_list_remove(client->pending_add, pending); - if (!_dbus_callback_check_and_init(msg, &iter, error)) - goto end; + //in case of error or when user cancel + if (edbus_message_error_get(msg, &errname, &errmsg)) + { + ERR("Error: %s %s\n", errname, errmsg); + goto end; + } - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_INT32)) - goto end; - - dbus_message_iter_get_basic(&iter, &id); + if (!edbus_message_arguments_get(msg, "i", &id)) + { + ERR("Error getting arguments."); + goto end; + } generating = calloc(1, sizeof(*generating)); generating->id = id; @@ -1195,15 +908,24 @@ _ethumb_client_queue_add_cb(void *data, DBusMessage *msg, DBusError *error) generating->free_data = pending->free_data; client->pending_gen = eina_list_append(client->pending_gen, generating); + free(pending); + return; + end: + eina_stringshare_del(pending->file); + eina_stringshare_del(pending->key); + eina_stringshare_del(pending->thumb); + eina_stringshare_del(pending->thumb_key); + if (pending->free_data) + pending->free_data(pending->data); free(pending); } static int _ethumb_client_queue_add(Ethumb_Client *client, const char *file, const char *key, const char *thumb, const char *thumb_key, Ethumb_Client_Generate_Cb generated_cb, const void *data, Eina_Free_Cb free_data) { - DBusMessage *msg; - DBusMessageIter iter; + EDBus_Message *msg; + EDBus_Message_Iter *main; struct _ethumb_pending_add *pending; pending = calloc(1, sizeof(*pending)); @@ -1219,46 +941,44 @@ _ethumb_client_queue_add(Ethumb_Client *client, const char *file, const char *ke client->id_count = (client->id_count + 1) % MAX_ID; - msg = dbus_message_new_method_call(_ethumb_dbus_bus_name, - client->object_path, - _ethumb_dbus_objects_interface, - "queue_add"); + msg = edbus_proxy_method_call_new(client->proxy, "queue_add"); + main = edbus_message_iter_get(msg); + edbus_message_iter_basic_append(main, 'i', pending->id); + _ethumb_client_dbus_append_bytearray(main, file); + _ethumb_client_dbus_append_bytearray(main, key); + _ethumb_client_dbus_append_bytearray(main, thumb); + _ethumb_client_dbus_append_bytearray(main, thumb_key); - dbus_message_iter_init_append(msg, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &pending->id); - _ethumb_client_dbus_append_bytearray(&iter, file); - _ethumb_client_dbus_append_bytearray(&iter, key); - _ethumb_client_dbus_append_bytearray(&iter, thumb); - _ethumb_client_dbus_append_bytearray(&iter, thumb_key); - - pending->pending_call = e_dbus_message_send(client->conn, msg, - _ethumb_client_queue_add_cb, - -1, pending); + pending->pending_call = edbus_proxy_send(client->proxy, msg, + _ethumb_client_queue_add_cb, + pending, -1); client->pending_add = eina_list_append(client->pending_add, pending); - dbus_message_unref(msg); + edbus_message_unref(msg); return pending->id; } static void -_ethumb_client_queue_remove_cb(void *data, DBusMessage *msg, DBusError *error) +_ethumb_client_queue_remove_cb(void *data, const EDBus_Message *msg, EDBus_Pending *edbus_pending) { - DBusMessageIter iter; - int t; - dbus_bool_t success = 0; + Eina_Bool success; struct _ethumb_pending_remove *pending = data; Ethumb_Client *client = pending->client; + const char *errname, *errmsg; client->pending_remove = eina_list_remove(client->pending_remove, pending); - if (!_dbus_callback_check_and_init(msg, &iter, error)) - goto end; + if (edbus_message_error_get(msg, &errname, &errmsg)) + { + ERR("Error: %s %s\n", errname, errmsg); + goto end; + } - t = dbus_message_iter_get_arg_type(&iter); - if (!_dbus_iter_type_check(t, DBUS_TYPE_BOOLEAN)) - goto end; - - dbus_message_iter_get_basic(&iter, &success); + if (edbus_message_arguments_get(msg, "b", &success)) + { + ERR("Error getting arguments."); + goto end; + } end: if (pending->cancel_cb) @@ -1290,11 +1010,10 @@ end: EAPI void ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Generate_Cancel_Cb cancel_cb, const void *data, Eina_Free_Cb free_data) { - DBusMessage *msg; struct _ethumb_pending_remove *pending; Eina_List *l; int found; - dbus_int32_t id32 = id; + int32_t id32 = id; EINA_SAFETY_ON_NULL_RETURN(client); EINA_SAFETY_ON_FALSE_RETURN(id >= 0); @@ -1305,17 +1024,15 @@ ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Gener pending->free_data = free_data; pending->client = client; - msg = dbus_message_new_method_call(_ethumb_dbus_bus_name, - client->object_path, - _ethumb_dbus_objects_interface, - "queue_remove"); - - dbus_message_append_args(msg, DBUS_TYPE_INT32, &id32, DBUS_TYPE_INVALID); - pending->pending_call = e_dbus_message_send(client->conn, msg, - _ethumb_client_queue_remove_cb, - -1, pending); + edbus_proxy_call(client->proxy, "queue_remove", + _ethumb_client_queue_remove_cb, pending, -1, "i", pending->id); client->pending_remove = eina_list_append(client->pending_remove, pending); + /* + * Check if answer was not received yet cancel it + * callback of queue_add will be called with a error msg + * and data will be freed + */ found = 0; l = client->pending_add; while (l) @@ -1326,23 +1043,15 @@ ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Gener l = l->next; continue; } - client->pending_add = eina_list_remove_list(client->pending_add, l); - eina_stringshare_del(pending_add->file); - eina_stringshare_del(pending_add->key); - eina_stringshare_del(pending_add->thumb); - eina_stringshare_del(pending_add->thumb_key); - dbus_pending_call_cancel(pending_add->pending_call); - dbus_pending_call_unref(pending_add->pending_call); - if (pending_add->free_data) - pending_add->free_data(pending_add->data); - free(pending_add); + edbus_pending_cancel(pending_add->pending_call); found = 1; break; } if (found) - goto end; + return; + //if already received answer only free memory l = client->pending_gen; while (l) { @@ -1362,20 +1071,6 @@ ethumb_client_generate_cancel(Ethumb_Client *client, int id, Ethumb_Client_Gener free(pending_gen); break; } - -end: - dbus_message_unref(msg); -} - -/** - * @cond LOCAL - */ -static void -_ethumb_client_queue_clear_cb(void *data, DBusMessage *msg __UNUSED__, DBusError *error __UNUSED__) -{ - Ethumb_Client *client = data; - - client->pending_clear = NULL; } /** @@ -1393,25 +1088,13 @@ _ethumb_client_queue_clear_cb(void *data, DBusMessage *msg __UNUSED__, DBusError EAPI void ethumb_client_generate_cancel_all(Ethumb_Client *client) { - DBusMessage *msg; void *data; EINA_SAFETY_ON_NULL_RETURN(client); - if (client->pending_clear) - return; - EINA_LIST_FREE(client->pending_add, data) { struct _ethumb_pending_add *pending = data; - eina_stringshare_del(pending->file); - eina_stringshare_del(pending->key); - eina_stringshare_del(pending->thumb); - eina_stringshare_del(pending->thumb_key); - dbus_pending_call_cancel(pending->pending_call); - dbus_pending_call_unref(pending->pending_call); - if (pending->free_data) - pending->free_data(pending->data); - free(pending); + edbus_pending_cancel(pending->pending_call); } EINA_LIST_FREE(client->pending_gen, data) @@ -1426,16 +1109,7 @@ ethumb_client_generate_cancel_all(Ethumb_Client *client) free(pending); } - msg = dbus_message_new_method_call(_ethumb_dbus_bus_name, - client->object_path, - _ethumb_dbus_objects_interface, - "queue_clear"); - - client->pending_clear = e_dbus_message_send(client->conn, msg, - _ethumb_client_queue_clear_cb, - -1, client); - - dbus_message_unref(msg); + edbus_proxy_call(client->proxy, "queue_clear", NULL, NULL, -1, ""); } /** @@ -2345,7 +2019,6 @@ ethumb_client_generate(Ethumb_Client *client, Ethumb_Client_Generate_Cb generate } id = _ethumb_client_queue_add(client, file, key, thumb, thumb_key, generated_cb, data, free_data); - return id; } @@ -2573,4 +2246,3 @@ ethumb_client_thumb_async_cancel(Ethumb_Client *client, Ethumb_Client_Async *req _ethumb_client_async_free(request); } -