From 9631258de40211a50c6960b48879554a412ea8bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Roberto=20de=20Souza?= Date: Wed, 2 Jan 2013 20:38:25 +0000 Subject: [PATCH] e: Port connman to edbus v2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Patch by: José Roberto de Souza SVN revision: 82014 --- configure.ac | 2 +- src/modules/connman/E_Connman.h | 28 +- src/modules/connman/agent.c | 267 ++++++------ src/modules/connman/e_connman.c | 692 ++++++++++--------------------- src/modules/connman/e_mod_main.c | 12 +- src/modules/connman/e_mod_main.h | 2 +- 6 files changed, 371 insertions(+), 632 deletions(-) diff --git a/configure.ac b/configure.ac index 881317d51..2c0eca690 100644 --- a/configure.ac +++ b/configure.ac @@ -792,7 +792,7 @@ AM_CONDITIONAL(HAVE_ECONNMAN, false) AM_CONDITIONAL(HAVE_DUMMY, false) define([CHECK_MODULE_CONNMAN], [ - AC_E_CHECK_PKG(ECONNMAN, [ edbus >= $efl_version ], [], [CONNMAN=false]) + AC_E_CHECK_PKG(ECONNMAN, [ edbus2 >= $efl_version ], [], [CONNMAN=false]) dnl AC_E_CHECK_PKG(DUMMY, [ connman >= 1.0 ], [], [CONNMAN=false]) ]) AC_SUBST(ECONNMAN_CFLAGS) diff --git a/src/modules/connman/E_Connman.h b/src/modules/connman/E_Connman.h index 452bfe327..f249da93d 100644 --- a/src/modules/connman/E_Connman.h +++ b/src/modules/connman/E_Connman.h @@ -3,6 +3,7 @@ #include "e.h" #include +#include typedef struct _E_Connman_Agent E_Connman_Agent; @@ -28,15 +29,11 @@ enum Connman_Service_Type CONNMAN_SERVICE_TYPE_CELLULAR, }; -struct Connman_Object -{ - const char *path; - Eina_List *handlers; /* E_DBus_Signal_Handler */ -}; - struct Connman_Manager { - struct Connman_Object obj; + const char *path; + EDBus_Proxy *technology_iface; + EDBus_Proxy *manager_iface; Eina_Inlist *services; /* The prioritized list of services */ @@ -48,17 +45,16 @@ struct Connman_Manager /* Private */ struct { - DBusPendingCall *get_services; - DBusPendingCall *get_properties; - DBusPendingCall *get_wifi_properties; - DBusPendingCall *set_powered; - DBusPendingCall *register_agent; + EDBus_Pending *get_services; + EDBus_Pending *get_wifi_properties; + EDBus_Pending *set_powered; } pending; }; struct Connman_Service { - struct Connman_Object obj; + const char *path; + EDBus_Proxy *service_iface; EINA_INLIST; /* Properties */ @@ -71,8 +67,8 @@ struct Connman_Service /* Private */ struct { - DBusPendingCall *connect; - DBusPendingCall *disconnect; + EDBus_Pending *connect; + EDBus_Pending *disconnect; void *data; } pending; }; @@ -83,7 +79,7 @@ extern int E_CONNMAN_EVENT_MANAGER_OUT; /* Daemon monitoring */ -unsigned int e_connman_system_init(E_DBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); +unsigned int e_connman_system_init(EDBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); unsigned int e_connman_system_shutdown(void); /* Requests from UI */ diff --git a/src/modules/connman/agent.c b/src/modules/connman/agent.c index 1d9f268c6..1c1e68711 100644 --- a/src/modules/connman/agent.c +++ b/src/modules/connman/agent.c @@ -10,6 +10,7 @@ #include "E_Connman.h" #include "e_mod_main.h" #define AGENT_IFACE "net.connman.Agent" +#define AGENT_KEY "agent" typedef struct _E_Connman_Agent_Input E_Connman_Agent_Input; @@ -33,27 +34,23 @@ struct _E_Connman_Agent_Input struct _E_Connman_Agent { E_Dialog *dialog; - E_DBus_Object *obj; - DBusMessage *msg; - E_DBus_Connection *conn; + EDBus_Service_Interface *iface; + EDBus_Message *msg; + EDBus_Connection *conn; Eina_Bool canceled:1; }; static void -_dict_append_basic(DBusMessageIter *dict, const char *key, void *val) +_dict_append_basic(EDBus_Message_Iter *array, const char *key, void *val) { - DBusMessageIter entry, value; + EDBus_Message_Iter *dict, *variant; - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); - - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_STRING_AS_STRING, &value); - dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &val); - dbus_message_iter_close_container(&entry, &value); - - dbus_message_iter_close_container(dict, &entry); + 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); } static void @@ -62,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; - DBusMessageIter iter, dict; + EDBus_Message_Iter *iter, *array; Eina_List *input_list, *l; - DBusMessage *reply; + EDBus_Message *reply; toolbook = agent->dialog->content_object; @@ -84,22 +81,15 @@ _dialog_ok_cb(void *data, E_Dialog *dialog) agent->canceled = EINA_FALSE; input_list = evas_object_data_get(list, "input_list"); - reply = dbus_message_new_method_return(agent->msg); - dbus_message_iter_init_append(reply, &iter); - - dbus_message_iter_open_container( - &iter, DBUS_TYPE_ARRAY, - DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING - DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING - DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); + reply = edbus_message_method_return_new(agent->msg); + iter = edbus_message_iter_get(reply); + edbus_message_iter_arguments_append(iter, "a{sv}", &array); EINA_LIST_FOREACH(input_list, l, input) - _dict_append_basic(&dict, input->key, input->value); + _dict_append_basic(array, input->key, input->value); + edbus_message_iter_container_close(iter, array); - dbus_message_iter_close_container(&iter, &dict); - - dbus_message_set_no_reply(reply, EINA_TRUE); - e_dbus_message_send(agent->conn, reply, NULL, -1, NULL); + edbus_connection_send(agent->conn, reply, NULL, NULL, -1); e_object_del(E_OBJECT(dialog)); } @@ -128,13 +118,12 @@ _dialog_key_down_cb(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, static void _dialog_cancel(E_Connman_Agent *agent) { - DBusMessage *reply; + EDBus_Message *reply; - reply = dbus_message_new_error(agent->msg, + reply = edbus_message_error_new(agent->msg, "net.connman.Agent.Error.Canceled", "User canceled dialog"); - dbus_message_set_no_reply(reply, EINA_TRUE); - e_dbus_message_send(agent->conn, reply, NULL, -1, NULL); + edbus_connection_send(agent->conn, reply, NULL, NULL, -1); } static void @@ -147,7 +136,7 @@ _dialog_del_cb(void *data) _dialog_cancel(agent); // FIXME need to mark cs->pending_connect = NULL; - dbus_message_unref(agent->msg); + edbus_message_unref(agent->msg); agent->dialog = NULL; } @@ -288,17 +277,18 @@ _dialog_new(E_Connman_Agent *agent) return dialog; } -static DBusMessage * -_agent_release(E_DBus_Object *obj, DBusMessage *msg) +static EDBus_Message * +_agent_release(const EDBus_Service_Interface *iface, + const EDBus_Message *msg) { E_Connman_Agent *agent; - DBusMessage *reply; + EDBus_Message *reply; DBG("Agent released"); - reply = dbus_message_new_method_return(msg); + reply = edbus_message_method_return_new(msg); - agent = e_dbus_object_data_get(obj); + agent = edbus_service_object_data_get(iface, AGENT_KEY); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply); if (agent->dialog) @@ -307,55 +297,49 @@ _agent_release(E_DBus_Object *obj, DBusMessage *msg) return reply; } -static DBusMessage * -_agent_report_error(E_DBus_Object *obj, DBusMessage *msg) +static EDBus_Message * +_agent_report_error(const EDBus_Service_Interface *iface, + const EDBus_Message *msg) { return NULL; } -static DBusMessage * -_agent_request_browser(E_DBus_Object *obj, DBusMessage *msg) +static EDBus_Message * +_agent_request_browser(const EDBus_Service_Interface *iface, + const EDBus_Message *msg) { return NULL; } static Eina_Bool _parse_field_value(struct Connman_Field *field, const char *key, - DBusMessageIter *value) + EDBus_Message_Iter *value, const char *signature) { if (!strcmp(key, "Type")) { - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_STRING, - EINA_FALSE); - dbus_message_iter_get_basic(value, &field->type); + EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); + edbus_message_iter_basic_get(value, &field->type); return EINA_TRUE; } if (!strcmp(key, "Requirement")) { - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_STRING, - EINA_FALSE); - dbus_message_iter_get_basic(value, &field->requirement); + EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); + edbus_message_iter_basic_get(value, &field->requirement); return EINA_TRUE; } if (!strcmp(key, "Alternates")) { - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_ARRAY, - EINA_FALSE); - /* ignore alternates */ + EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 'a', EINA_FALSE); + /* ignore alternates */ return EINA_TRUE; } if (!strcmp(key, "Value")) { - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_STRING, - EINA_FALSE); - dbus_message_iter_get_basic(value, &field->value); + EINA_SAFETY_ON_FALSE_RETURN_VAL(signature[0] == 's', EINA_FALSE); + edbus_message_iter_basic_get(value, &field->value); return EINA_TRUE; } @@ -364,59 +348,57 @@ _parse_field_value(struct Connman_Field *field, const char *key, } static Eina_Bool -_parse_field(struct Connman_Field *field, DBusMessageIter *value) +_parse_field(struct Connman_Field *field, EDBus_Message_Iter *value, + const char *signature) { - DBusMessageIter dict; + EDBus_Message_Iter *array, *dict; - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_ARRAY, EINA_FALSE); - dbus_message_iter_recurse(value, &dict); + edbus_message_iter_arguments_get(value, "a{sv}", &array); + EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE); - for (; dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&dict)) + while (edbus_message_iter_get_and_next(array, 'e', &dict)) { - DBusMessageIter entry, var; + EDBus_Message_Iter *var; const char *key; + char *sig2; - dbus_message_iter_recurse(&dict, &entry); - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING, - EINA_FALSE); - dbus_message_iter_get_basic(&entry, &key); - - dbus_message_iter_next(&entry); - EINA_SAFETY_ON_FALSE_RETURN_VAL( - dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_VARIANT, - EINA_FALSE); - dbus_message_iter_recurse(&entry, &var); - - if (!_parse_field_value(field, key, &var)) + if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) return EINA_FALSE; + sig2 = edbus_message_iter_signature_get(var); + if (!sig2) + return EINA_FALSE; + + if (!_parse_field_value(field, key, var, sig2)) + { + free(sig2); + return EINA_FALSE; + } + free(sig2); } return EINA_TRUE; } -static DBusMessage * -_agent_request_input(E_DBus_Object *obj, DBusMessage *msg) +static EDBus_Message * +_agent_request_input(const EDBus_Service_Interface *iface, + const EDBus_Message *msg) { E_Connman_Module_Context *ctxt = connman_mod->data; const Eina_List *l; E_Connman_Instance *inst; - DBusMessageIter iter, dict; + EDBus_Message_Iter *array, *dict; E_Connman_Agent *agent; - DBusMessage *reply; const char *path; - agent = e_dbus_object_data_get(obj); + agent = edbus_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) - dbus_message_unref(agent->msg); - agent->msg = dbus_message_ref(msg); + edbus_message_unref(agent->msg); + agent->msg = edbus_message_ref((EDBus_Message *)msg); EINA_LIST_FOREACH(ctxt->instances, l, inst) econnman_popup_del(inst); @@ -426,34 +408,26 @@ _agent_request_input(E_DBus_Object *obj, DBusMessage *msg) agent->dialog = _dialog_new(agent); EINA_SAFETY_ON_NULL_GOTO(agent->dialog, err); - dbus_message_iter_init(msg, &iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) + if (!edbus_message_arguments_get(msg, "oa{sv}", &path, &array)) goto err; - dbus_message_iter_get_basic(&iter, &path); - dbus_message_iter_next(&iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) - goto err; - dbus_message_iter_recurse(&iter, &dict); - - for (; dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&dict)) + while (edbus_message_iter_get_and_next(array, 'e', &dict)) { + EDBus_Message_Iter *var; + char *signature; struct Connman_Field field = { NULL, NULL, NULL, NULL, NULL }; - DBusMessageIter entry, var; - dbus_message_iter_recurse(&dict, &entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) + if (!edbus_message_iter_arguments_get(dict, "sv", &field.name, &var)) goto err; - dbus_message_iter_get_basic(&entry, &field.name); + signature = edbus_message_iter_signature_get(var); + if (!signature) goto err; - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) - goto err; - dbus_message_iter_recurse(&entry, &var); - - if (!_parse_field(&field, &var)) - return NULL; + if (!_parse_field(&field, var, signature)) + { + free(signature); + goto err; + } + free(signature); DBG("AGENT Got field:\n" "\tName: %s\n" @@ -469,24 +443,22 @@ _agent_request_input(E_DBus_Object *obj, DBusMessage *msg) return NULL; err: - dbus_message_unref(msg); + edbus_message_unref((EDBus_Message *)msg); agent->msg = NULL; WRN("Failed to parse msg"); - reply = dbus_message_new_method_return(msg); - return reply; + return edbus_message_method_return_new(msg); } -static DBusMessage * -_agent_cancel(E_DBus_Object *obj, DBusMessage *msg) +static EDBus_Message * +_agent_cancel(const EDBus_Service_Interface *iface, + const EDBus_Message *msg) { E_Connman_Agent *agent; - DBusMessage *reply; + EDBus_Message *reply = edbus_message_method_return_new(msg); DBG("Agent canceled"); - reply = dbus_message_new_method_return(msg); - - agent = e_dbus_object_data_get(obj); + agent = edbus_service_object_data_get(iface, AGENT_KEY); EINA_SAFETY_ON_FALSE_RETURN_VAL(agent, reply); if (agent->dialog) @@ -495,47 +467,48 @@ _agent_cancel(E_DBus_Object *obj, DBusMessage *msg) return reply; } +static const EDBus_Method methods[] = { + { "Release", NULL, NULL, _agent_release, 0 }, + { + "ReportError", EDBUS_ARGS({"o", "service"}, {"s", "error"}), NULL, + _agent_report_error, 0 + }, + { + "RequestBrowser", EDBUS_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 + }, + { "Cancel", NULL, NULL, _agent_cancel, 0 }, + { NULL, NULL, NULL, NULL, 0 } +}; + +static const EDBus_Service_Interface_Desc desc = { + AGENT_IFACE, methods, NULL, NULL, NULL, NULL +}; + E_Connman_Agent * -econnman_agent_new(E_DBus_Connection *edbus_conn) +econnman_agent_new(EDBus_Connection *edbus_conn) { - E_DBus_Object *agent_obj; - E_DBus_Interface *iface; + EDBus_Service_Interface *iface; E_Connman_Agent *agent; agent = E_NEW(E_Connman_Agent, 1); EINA_SAFETY_ON_NULL_RETURN_VAL(agent, NULL); - iface = e_dbus_interface_new(AGENT_IFACE); + iface = edbus_service_interface_register(edbus_conn, AGENT_PATH, &desc); if (!iface) { - ERR("Failed to create e_dbus interface"); + ERR("Failed to create edbus interface"); free(agent); return NULL; } + edbus_service_object_data_set(iface, AGENT_KEY, agent); - e_dbus_interface_method_add(iface, "Release", "", "", _agent_release); - e_dbus_interface_method_add(iface, "ReportError", "os", "", - _agent_report_error); - e_dbus_interface_method_add(iface, "RequestBrowser", "os", "", - _agent_request_browser); - e_dbus_interface_method_add(iface, "RequestInput", "oa{sv}", "a{sv}", - _agent_request_input); - e_dbus_interface_method_add(iface, "Cancel", "", "", _agent_cancel); - - agent_obj = e_dbus_object_add(edbus_conn, AGENT_PATH, agent); - if (!agent_obj) - { - ERR("Failed to create e_dbus object"); - e_dbus_interface_unref(iface); - free(agent); - return NULL; - } - - agent->obj = agent_obj; + agent->iface = iface; agent->conn = edbus_conn; - e_dbus_object_interface_attach(agent_obj, iface); - - e_dbus_interface_unref(iface); return agent; } @@ -544,6 +517,6 @@ void econnman_agent_del(E_Connman_Agent *agent) { EINA_SAFETY_ON_NULL_RETURN(agent); - e_dbus_object_free(agent->obj); + edbus_service_object_unregister(agent->iface); free(agent); } diff --git a/src/modules/connman/e_connman.c b/src/modules/connman/e_connman.c index 5feaa3282..6f7cfe8de 100644 --- a/src/modules/connman/e_connman.c +++ b/src/modules/connman/e_connman.c @@ -9,14 +9,10 @@ #define CONNMAN_CONNECTION_TIMEOUT 60 * MILLI_PER_SEC static unsigned int init_count; -static E_DBus_Connection *conn; -static char *bus_owner; +static EDBus_Connection *conn; static struct Connman_Manager *connman_manager; static E_Connman_Agent *agent; -static DBusPendingCall *pending_get_name_owner; -static E_DBus_Signal_Handler *handler_name_owner; - EAPI int E_CONNMAN_EVENT_MANAGER_IN; EAPI int E_CONNMAN_EVENT_MANAGER_OUT; @@ -34,25 +30,17 @@ static void _eina_str_array_clean(Eina_Array *array) eina_array_clean(array); } -static bool _dbus_bool_get(DBusMessageIter *itr) -{ - dbus_bool_t val; - dbus_message_iter_get_basic(itr, &val); - return val; -} - -static void _dbus_str_array_to_eina(DBusMessageIter *value, Eina_Array **old, +static void _dbus_str_array_to_eina(EDBus_Message_Iter *value, Eina_Array **old, unsigned nelem) { - DBusMessageIter itr; + EDBus_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( - dbus_message_iter_get_arg_type(value) == DBUS_TYPE_ARRAY); - - dbus_message_iter_recurse(value, &itr); + EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, "as", + &itr_array)); array = *old; if (array == NULL) @@ -63,18 +51,8 @@ static void _dbus_str_array_to_eina(DBusMessageIter *value, Eina_Array **old, else _eina_str_array_clean(array); - for (; dbus_message_iter_get_arg_type(&itr) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&itr)) + while (edbus_message_iter_get_and_next(itr_array, 's', &s)) { - const char *s; - if (dbus_message_iter_get_arg_type(&itr) != DBUS_TYPE_STRING) - { - ERR("Unexpected D-Bus type %d", - dbus_message_iter_get_arg_type(&itr)); - continue; - } - - dbus_message_iter_get_basic(&itr, &s); eina_array_push(array, eina_stringshare_add(s)); DBG("Push %s", s); } @@ -168,38 +146,27 @@ const char *econnman_service_type_to_str(enum Connman_Service_Type type) /* ---- */ -static void _connman_object_init(struct Connman_Object *obj, const char *path) -{ - obj->path = eina_stringshare_add(path); -} - -static void _connman_object_clear(struct Connman_Object *obj) -{ - E_DBus_Signal_Handler *h; - - EINA_LIST_FREE(obj->handlers, h) - e_dbus_signal_handler_del(conn, h); - - eina_stringshare_del(obj->path); -} - static void _service_parse_prop_changed(struct Connman_Service *cs, const char *prop_name, - DBusMessageIter *value) + EDBus_Message_Iter *value) { - DBG("service %p %s prop %s", cs, cs->obj.path, prop_name); + DBG("service %p %s prop %s", cs, cs->path, prop_name); if (strcmp(prop_name, "State") == 0) { const char *state; - dbus_message_iter_get_basic(value, &state); + EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + "s", + &state)); cs->state = str_to_state(state); DBG("New state: %s %d", state, cs->state); } else if (strcmp(prop_name, "Name") == 0) { const char *name; - dbus_message_iter_get_basic(value, &name); + EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + "s", + &name)); free(cs->name); cs->name = strdup(name); DBG("New name: %s", cs->name); @@ -207,16 +174,20 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, else if (strcmp(prop_name, "Type") == 0) { const char *type; - dbus_message_iter_get_basic(value, &type); + EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + "s", + &type)); cs->type = str_to_type(type); DBG("New type: %s %d", type, cs->type); } else if (strcmp(prop_name, "Strength") == 0) { uint8_t strength; - dbus_message_iter_get_basic(value, &strength); + EINA_SAFETY_ON_FALSE_RETURN(edbus_message_iter_arguments_get(value, + "y", + &strength)); cs->strength = strength; - DBG("New strength: %d", strength);; + DBG("New strength: %d", strength); } else if (strcmp(prop_name, "Security") == 0) { @@ -228,46 +199,30 @@ static void _service_parse_prop_changed(struct Connman_Service *cs, } static void _service_prop_dict_changed(struct Connman_Service *cs, - DBusMessageIter *dict) + EDBus_Message_Iter *props) { - for (; dbus_message_iter_get_arg_type(dict) != DBUS_TYPE_INVALID; - dbus_message_iter_next(dict)) + EDBus_Message_Iter *dict; + while (edbus_message_iter_get_and_next(props, 'e', &dict)) { - DBusMessageIter entry, var; - const char *name; + char *name; + EDBus_Message_Iter *var; - dbus_message_iter_recurse(dict, &entry); - - EINA_SAFETY_ON_FALSE_RETURN( - dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING); - dbus_message_iter_get_basic(&entry, &name); - - dbus_message_iter_next(&entry); - EINA_SAFETY_ON_FALSE_RETURN( - dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_VARIANT); - dbus_message_iter_recurse(&entry, &var); - - _service_parse_prop_changed(cs, name, &var); + if (!edbus_message_iter_arguments_get(dict, "sv", &name, &var)) + continue; + _service_parse_prop_changed(cs, name, var); } } -static void _service_prop_changed(void *data, DBusMessage *msg) +static void _service_prop_changed(void *data, const EDBus_Message *msg) { struct Connman_Service *cs = data; - DBusMessageIter iter, var; + EDBus_Message_Iter *var; const char *name; - if (!msg || !dbus_message_iter_init(msg, &iter)) - { - ERR("Could not parse message %p", msg); - return; - } + if (!edbus_message_arguments_get(msg, "sv", &name, &var)) + return; - dbus_message_iter_get_basic(&iter, &name); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &var); - - _service_parse_prop_changed(cs, name, &var); + _service_parse_prop_changed(cs, name, var); } struct connection_data { @@ -278,57 +233,62 @@ struct connection_data { static void _service_free(struct Connman_Service *cs) { + EDBus_Object *obj; if (!cs) return; if (cs->pending.connect) { - dbus_pending_call_cancel(cs->pending.connect); + edbus_pending_cancel(cs->pending.connect); free(cs->pending.data); } if (cs->pending.disconnect) { - dbus_pending_call_cancel(cs->pending.disconnect); + edbus_pending_cancel(cs->pending.disconnect); free(cs->pending.data); } free(cs->name); _eina_str_array_clean(cs->security); eina_array_free(cs->security); - _connman_object_clear(&cs->obj); + eina_stringshare_del(cs->path); + obj = edbus_proxy_object_get(cs->service_iface); + edbus_proxy_unref(cs->service_iface); + edbus_object_unref(obj); free(cs); } -static struct Connman_Service *_service_new(const char *path, DBusMessageIter *props) +static struct Connman_Service *_service_new(const char *path, EDBus_Message_Iter *props) { struct Connman_Service *cs; - E_DBus_Signal_Handler *h; + EDBus_Object *obj; EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL); cs = calloc(1, sizeof(*cs)); EINA_SAFETY_ON_NULL_RETURN_VAL(cs, NULL); - _connman_object_init(&cs->obj, path); + cs->path = eina_stringshare_add(path); - h = e_dbus_signal_handler_add(conn, bus_owner, - path, CONNMAN_SERVICE_IFACE, "PropertyChanged", - _service_prop_changed, cs); - cs->obj.handlers = eina_list_append(cs->obj.handlers, h); + 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", + _service_prop_changed, cs); _service_prop_dict_changed(cs, props); return cs; } -static void _service_connection_cb(void *data, DBusMessage *reply, - DBusError *err) +static void _service_connection_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { struct connection_data *cd = data; if (cd->cb) { - const char *s = dbus_error_is_set(err) ? err->message : NULL; + const char *s = NULL; + edbus_message_error_get(msg, NULL, &s); cd->cb(cd->user_data, s); } @@ -342,7 +302,6 @@ static void _service_connection_cb(void *data, DBusMessage *reply, bool econnman_service_connect(struct Connman_Service *cs, Econnman_Simple_Cb cb, void *data) { - DBusMessage *msg; struct connection_data *cd; EINA_SAFETY_ON_NULL_RETURN_VAL(cs, false); @@ -354,10 +313,6 @@ bool econnman_service_connect(struct Connman_Service *cs, return false; } - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, cs->obj.path, - CONNMAN_SERVICE_IFACE, "Connect"); - EINA_SAFETY_ON_NULL_RETURN_VAL(msg, false); - cd = calloc(1, sizeof(*cd)); EINA_SAFETY_ON_NULL_GOTO(cd, fail); @@ -365,20 +320,18 @@ bool econnman_service_connect(struct Connman_Service *cs, cd->cb = cb; cd->user_data = data; - cs->pending.connect = e_dbus_message_send(conn, msg, - _service_connection_cb, CONNMAN_CONNECTION_TIMEOUT, cd); - + cs->pending.connect = edbus_proxy_call(cs->service_iface, "Connect", + _service_connection_cb, cd, + CONNMAN_CONNECTION_TIMEOUT, ""); return true; fail: - dbus_message_unref(msg); return false; } bool econnman_service_disconnect(struct Connman_Service *cs, Econnman_Simple_Cb cb, void *data) { - DBusMessage *msg; struct connection_data *cd; EINA_SAFETY_ON_NULL_RETURN_VAL(cs, false); @@ -390,10 +343,6 @@ bool econnman_service_disconnect(struct Connman_Service *cs, return false; } - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, cs->obj.path, - CONNMAN_SERVICE_IFACE, "Disconnect"); - EINA_SAFETY_ON_NULL_RETURN_VAL(msg, false); - cd = calloc(1, sizeof(*cd)); EINA_SAFETY_ON_NULL_GOTO(cd, fail); @@ -401,13 +350,12 @@ bool econnman_service_disconnect(struct Connman_Service *cs, cd->cb = cb; cd->user_data = data; - cs->pending.connect = e_dbus_message_send(conn, msg, - _service_connection_cb, -1, cd); - + cs->pending.connect = edbus_proxy_call(cs->service_iface, "Disconnect", + _service_connection_cb, cd, + -1, ""); return true; fail: - dbus_message_unref(msg); return false; } @@ -418,7 +366,7 @@ static struct Connman_Service *_manager_find_service_stringshared( EINA_INLIST_FOREACH(cm->services, cs) { - if (cs->obj.path == path) + if (cs->path == path) { found = cs; break; @@ -439,21 +387,12 @@ struct Connman_Service *econnman_manager_find_service(struct Connman_Manager *cm } static void _manager_services_remove(struct Connman_Manager *cm, - DBusMessageIter *array) + EDBus_Message_Iter *array) { - for (; dbus_message_iter_get_arg_type(array) != DBUS_TYPE_INVALID; - dbus_message_iter_next(array)) + const char *path; + while (edbus_message_iter_get_and_next(array, 'o', &path)) { struct Connman_Service *cs; - const char *path; - - if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_OBJECT_PATH) - { - ERR("Unexpected D-Bus type %d", - dbus_message_iter_get_arg_type(array)); - continue; - } - dbus_message_iter_get_basic(array, &path); cs = econnman_manager_find_service(cm, path); if (cs == NULL) { @@ -461,80 +400,51 @@ static void _manager_services_remove(struct Connman_Manager *cm, path); continue; } - cm->services = eina_inlist_remove(cm->services, EINA_INLIST_GET(cs)); DBG("Removed service: %p %s", cs, path); _service_free(cs); } } -static void _manager_services_changed(void *data, DBusMessage *msg) +static void _manager_services_changed(void *data, const EDBus_Message *msg) { struct Connman_Manager *cm = data; - DBusMessageIter iter, changed, removed; + EDBus_Message_Iter *changed, *removed, *s; Eina_Inlist *tmp = NULL; if (cm->pending.get_services) return; - dbus_message_iter_init(msg, &iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) + if (!edbus_message_arguments_get(msg, "a(oa{sv})ao", &changed, &removed)) { - ERR("type=%d", dbus_message_iter_get_arg_type(&iter)); + ERR("Error getting arguments"); return; } - dbus_message_iter_recurse(&iter, &changed); - dbus_message_iter_next(&iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) - { - ERR("type=%d", dbus_message_iter_get_arg_type(&iter)); - return; - } - dbus_message_iter_recurse(&iter, &removed); + _manager_services_remove(cm, removed); - _manager_services_remove(cm, &removed); - - for (; dbus_message_iter_get_arg_type(&changed) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&changed)) + while (edbus_message_iter_get_and_next(changed, 'r', &s)) { struct Connman_Service *cs; - DBusMessageIter entry, dict; const char *path; + EDBus_Message_Iter *array; - dbus_message_iter_recurse(&changed, &entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_OBJECT_PATH) - { - ERR("Unexpected D-Bus type %d", - dbus_message_iter_get_arg_type(&entry)); - continue; - } - dbus_message_iter_get_basic(&entry, &path); + if (!edbus_message_iter_arguments_get(s, "oa{sv}", &path, &array)) + continue; cs = econnman_manager_find_service(cm, path); - - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_ARRAY) + if (!cs) { - ERR("Unexpected D-Bus type %d", - dbus_message_iter_get_arg_type(&entry)); - continue; - } - dbus_message_iter_recurse(&entry, &dict); - - if (cs == NULL) - { - cs = _service_new(path, &dict); + cs = _service_new(path, array); DBG("Added service: %p %s", cs, path); } else { - _service_prop_dict_changed(cs, &dict); + _service_prop_dict_changed(cs, array); cm->services = eina_inlist_remove(cm->services, EINA_INLIST_GET(cs)); DBG("Changed service: %p %s", cs, path); } - tmp = eina_inlist_append(tmp, EINA_INLIST_GET(cs)); } @@ -542,68 +452,64 @@ static void _manager_services_changed(void *data, DBusMessage *msg) econnman_mod_services_changed(cm); } -static void _manager_get_services_cb(void *data, DBusMessage *reply, - DBusError *err) +static void _manager_get_services_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { struct Connman_Manager *cm = data; - DBusMessageIter iter, array; + EDBus_Message_Iter *array, *s; + const char *name, *text; cm->pending.get_services = NULL; - if (dbus_error_is_set(err)) + if (edbus_message_error_get(msg, &name, &text)) { - DBG("Could not get services. %s: %s", err->name, err->message); + ERR("Could not get services. %s: %s", name, text); return; } - DBG("cm->services=%p", cm->services); - dbus_message_iter_init(reply, &iter); - if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) + if (!edbus_message_arguments_get(msg, "a(oa{sv})", &array)) { - ERR("type=%d", dbus_message_iter_get_arg_type(&iter)); + ERR("Error getting array"); return; } - dbus_message_iter_recurse(&iter, &array); - - for (; dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&array)) + while (edbus_message_iter_get_and_next(array, 'r', &s)) { struct Connman_Service *cs; const char *path; - DBusMessageIter entry, dict; + EDBus_Message_Iter *inner_array; - dbus_message_iter_recurse(&array, &entry); - dbus_message_iter_get_basic(&entry, &path); - dbus_message_iter_next(&entry); - dbus_message_iter_recurse(&entry, &dict); - - cs = _service_new(path, &dict); + if (!edbus_message_iter_arguments_get(s, "oa{sv}", &path, &inner_array)) + continue; + cs = _service_new(path, inner_array); if (cs == NULL) continue; cm->services = eina_inlist_append(cm->services, EINA_INLIST_GET(cs)); DBG("Added service: %p %s", cs, path); } - econnman_mod_services_changed(cm); } static bool _manager_parse_prop_changed(struct Connman_Manager *cm, const char *name, - DBusMessageIter *value) + EDBus_Message_Iter *value) { if (strcmp(name, "State") == 0) { const char *state; - dbus_message_iter_get_basic(value, &state); + if (!edbus_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) - cm->offline_mode = _dbus_bool_get(value); + { + if (!edbus_message_iter_arguments_get(value, "b", &cm->offline_mode)) + return false; + } else return false; @@ -611,63 +517,58 @@ static bool _manager_parse_prop_changed(struct Connman_Manager *cm, return true; } -static void _manager_prop_changed(void *data, DBusMessage *msg) +static void +_manager_prop_changed(void *data, const EDBus_Message *msg) { struct Connman_Manager *cm = data; - DBusMessageIter iter, var; + EDBus_Message_Iter *var; const char *name; - if (!msg || !dbus_message_iter_init(msg, &iter)) + if (!edbus_message_arguments_get(msg, "sv", &name, &var)) { ERR("Could not parse message %p", msg); return; } - dbus_message_iter_get_basic(&iter, &name); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &var); - - _manager_parse_prop_changed(cm, name, &var); + _manager_parse_prop_changed(cm, name, var); } -static void _manager_get_prop_cb(void *data, DBusMessage *reply, - DBusError *err) +static void _manager_get_prop_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { struct Connman_Manager *cm = data; - DBusMessageIter iter, dict; + EDBus_Message_Iter *array, *dict; + const char *name, *text; - cm->pending.get_properties = NULL; - - if (dbus_error_is_set(err)) + if (edbus_message_error_get(msg, &name, &text)) { - DBG("Could not get properties. %s: %s", err->name, err->message); + ERR("Could not get properties. %s: %s", name, text); return; } - dbus_message_iter_init(reply, &iter); - dbus_message_iter_recurse(&iter, &dict); - - for (; dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&dict)) + if (!edbus_message_arguments_get(msg, "a{sv}", &array)) { - DBusMessageIter entry, var; - const char *name; + ERR("Error getting arguments."); + return; + } - dbus_message_iter_recurse(&dict, &entry); - dbus_message_iter_get_basic(&entry, &name); - dbus_message_iter_next(&entry); - dbus_message_iter_recurse(&entry, &var); + while (edbus_message_iter_get_and_next(array, 'e', &dict)) + { + const char *key; + EDBus_Message_Iter *var; - _manager_parse_prop_changed(cm, name, &var); + if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + continue; + _manager_parse_prop_changed(cm, key, var); } } static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm, const char *name, - DBusMessageIter *value) + EDBus_Message_Iter *value) { - if (strcmp(name, "Powered") == 0) - cm->powered = _dbus_bool_get(value); + if (!strcmp(name, "Powered")) + return edbus_message_iter_arguments_get(value, "b", &cm->powered); else return false; @@ -675,89 +576,69 @@ static bool _manager_parse_wifi_prop_changed(struct Connman_Manager *cm, return true; } -static void _manager_wifi_prop_changed(void *data, DBusMessage *msg) +static void _manager_wifi_prop_changed(void *data, const EDBus_Message *msg) { struct Connman_Manager *cm = data; - DBusMessageIter iter, var; + EDBus_Message_Iter *var; const char *name; - if (!msg || !dbus_message_iter_init(msg, &iter)) + if (!edbus_message_arguments_get(msg, "sv", &name, &var)) { ERR("Could not parse message %p", msg); return; } - dbus_message_iter_get_basic(&iter, &name); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &var); - - _manager_parse_wifi_prop_changed(cm, name, &var); + _manager_parse_wifi_prop_changed(cm, name, var); } -static void _manager_get_wifi_prop_cb(void *data, DBusMessage *reply, - DBusError *err) +static void _manager_get_wifi_prop_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { struct Connman_Manager *cm = data; - DBusMessageIter iter, dict; + EDBus_Message_Iter *array, *dict; + const char *name, *message; cm->pending.get_wifi_properties = NULL; - if (dbus_error_is_set(err)) + if (edbus_message_error_get(msg, &name, &message)) { - DBG("Could not get properties. %s: %s", err->name, err->message); + ERR("Could not get properties. %s: %s", name, message); return; } - dbus_message_iter_init(reply, &iter); - dbus_message_iter_recurse(&iter, &dict); - - for (; dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_INVALID; - dbus_message_iter_next(&dict)) + if (!edbus_message_arguments_get(msg, "a{sv}", &array)) { - DBusMessageIter entry, var; - const char *name; + ERR("Error getting arguments."); + return; + } - dbus_message_iter_recurse(&dict, &entry); - dbus_message_iter_get_basic(&entry, &name); - dbus_message_iter_next(&entry); - dbus_message_iter_recurse(&entry, &var); + while (edbus_message_iter_get_and_next(array, 'e', &dict)) + { + EDBus_Message_Iter *var; + const char *key; - _manager_parse_wifi_prop_changed(cm, name, &var); + if (!edbus_message_iter_arguments_get(dict, "sv", &key, &var)) + continue; + _manager_parse_wifi_prop_changed(cm, key, var); } } static void -_manager_agent_unregister(void) +_manager_agent_unregister(struct Connman_Manager *cm) { - const char *path = AGENT_PATH; - DBusMessageIter itr; - DBusMessage *msg; - - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, "/", - CONNMAN_MANAGER_IFACE, "UnregisterAgent"); - - if (!msg) - { - ERR("Could not create D-Bus message"); - return; - } - - dbus_message_iter_init_append(msg, &itr); - dbus_message_iter_append_basic(&itr, DBUS_TYPE_OBJECT_PATH, &path); - - e_dbus_message_send(conn, msg, NULL, -1, NULL); + edbus_proxy_call(cm->manager_iface, "UnregisterAgent", NULL, NULL, -1, "o", + AGENT_PATH); } static void -_manager_agent_register_cb(void *data, DBusMessage *reply, DBusError *err) +_manager_agent_register_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { - struct Connman_Manager *cm = data; + const char *name, *text; - cm->pending.register_agent = NULL; - - if (dbus_error_is_set(err)) + if (edbus_message_error_get(msg, &name, &text)) { - WRN("Could not register agent. %s: %s", err->name, err->message); + WRN("Could not register agent. %s: %s", name, text); return; } @@ -767,32 +648,16 @@ _manager_agent_register_cb(void *data, DBusMessage *reply, DBusError *err) static void _manager_agent_register(struct Connman_Manager *cm) { - const char *path = AGENT_PATH; - DBusMessageIter itr; - DBusMessage *msg; - if (!cm) return; - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, "/", - CONNMAN_MANAGER_IFACE, "RegisterAgent"); - - if (!msg) - { - ERR("Could not create D-Bus message"); - return; - } - - dbus_message_iter_init_append(msg, &itr); - dbus_message_iter_append_basic(&itr, DBUS_TYPE_OBJECT_PATH, &path); - - cm->pending.register_agent = e_dbus_message_send(conn, msg, - _manager_agent_register_cb, - -1, cm); + edbus_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; if (!cm) return; @@ -805,228 +670,135 @@ static void _manager_free(struct Connman_Manager *cm) } if (cm->pending.get_services) - { - dbus_pending_call_cancel(cm->pending.get_services); - cm->pending.get_services = NULL; - } - - if (cm->pending.get_properties) - { - dbus_pending_call_cancel(cm->pending.get_properties); - cm->pending.get_properties = NULL; - } + edbus_pending_cancel(cm->pending.get_services); if (cm->pending.get_wifi_properties) - { - dbus_pending_call_cancel(cm->pending.get_wifi_properties); - cm->pending.get_wifi_properties = NULL; - } + edbus_pending_cancel(cm->pending.get_wifi_properties); if (cm->pending.set_powered) - { - dbus_pending_call_cancel(cm->pending.set_powered); - cm->pending.set_powered = NULL; - } + edbus_pending_cancel(cm->pending.set_powered); - if (cm->pending.register_agent) - { - dbus_pending_call_cancel(cm->pending.register_agent); - cm->pending.register_agent = NULL; - } - - _connman_object_clear(&cm->obj); + 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); free(cm); } -static void _manager_powered_cb(void *data, DBusMessage *reply, - DBusError *err) +static void _manager_powered_cb(void *data, const EDBus_Message *msg, + EDBus_Pending *pending) { + EDBus_Pending *p; struct Connman_Manager *cm = data; - DBusMessage *msg; + const char *error_name, *error_msg; cm->pending.set_powered = NULL; - if (!((err) && (dbus_error_is_set(err)))) + + if (edbus_message_error_get(msg, &error_name, &error_msg)) { - if (cm->pending.get_wifi_properties) - dbus_pending_call_cancel(cm->pending.get_wifi_properties); - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, - "/net/connman/technology/wifi", - CONNMAN_TECHNOLOGY_IFACE, - "GetProperties"); - cm->pending.get_wifi_properties = - e_dbus_message_send(conn, msg, _manager_get_wifi_prop_cb, -1, cm); + 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", + _manager_get_wifi_prop_cb, cm, -1, ""); + cm->pending.get_wifi_properties = p; } void econnman_powered_set(struct Connman_Manager *cm, Eina_Bool powered) { - DBusMessageIter itr, var; - DBusMessage *msg; - const char *p = "Powered"; - int v = 0; - - if (powered) v = 1; - if (cm->pending.set_powered) - dbus_pending_call_cancel(cm->pending.set_powered); - msg = dbus_message_new_method_call(CONNMAN_BUS_NAME, - "/net/connman/technology/wifi", - CONNMAN_TECHNOLOGY_IFACE, - "SetProperty"); - dbus_message_iter_init_append(msg, &itr); - dbus_message_iter_append_basic(&itr, DBUS_TYPE_STRING, &p); - if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, "b", &var)) - { - dbus_message_iter_append_basic(&var, DBUS_TYPE_BOOLEAN, &v); - dbus_message_iter_close_container(&itr, &var); - } - cm->pending.set_powered = - e_dbus_message_send(conn, msg, _manager_powered_cb, -1, cm); + EDBus_Message_Iter *main_iter, *var; + EDBus_Message *msg; + if (cm->pending.set_powered) + edbus_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); + + cm->pending.set_powered = edbus_proxy_send(cm->technology_iface, msg, + _manager_powered_cb, cm, -1); } static struct Connman_Manager *_manager_new(void) { - DBusMessage *msg_props, *msg_services, *msg_wifi_props; const char *path = "/"; - struct E_DBus_Signal_Handler *h; struct Connman_Manager *cm; - - msg_services = dbus_message_new_method_call(CONNMAN_BUS_NAME, "/", - CONNMAN_MANAGER_IFACE, - "GetServices"); - msg_props = dbus_message_new_method_call(CONNMAN_BUS_NAME, "/", - CONNMAN_MANAGER_IFACE, - "GetProperties"); - msg_wifi_props = dbus_message_new_method_call(CONNMAN_BUS_NAME, - "/net/connman/technology/wifi", - CONNMAN_TECHNOLOGY_IFACE, - "GetProperties"); - if (!msg_services || !msg_props) - { - ERR("Could not create D-Bus messages"); - return NULL; - } + EDBus_Object *obj; cm = calloc(1, sizeof(*cm)); EINA_SAFETY_ON_NULL_RETURN_VAL(cm, NULL); - _connman_object_init(&cm->obj, path); - h = e_dbus_signal_handler_add(conn, bus_owner, - path, CONNMAN_MANAGER_IFACE, "PropertyChanged", - _manager_prop_changed, cm); - cm->obj.handlers = eina_list_append(cm->obj.handlers, h); + 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, + "/net/connman/technology/wifi"); + cm->technology_iface = edbus_proxy_get(obj, CONNMAN_TECHNOLOGY_IFACE); - h = e_dbus_signal_handler_add(conn, bus_owner, - path, CONNMAN_MANAGER_IFACE, "ServicesChanged", - _manager_services_changed, cm); - cm->obj.handlers = eina_list_append(cm->obj.handlers, h); + cm->path = eina_stringshare_add(path); - h = e_dbus_signal_handler_add(conn, bus_owner, - "/net/connman/technology/wifi", - CONNMAN_TECHNOLOGY_IFACE, "PropertyChanged", - _manager_wifi_prop_changed, cm); - cm->obj.handlers = eina_list_append(cm->obj.handlers, h); + edbus_proxy_signal_handler_add(cm->manager_iface, "PropertyChanged", + _manager_prop_changed, cm); + edbus_proxy_signal_handler_add(cm->manager_iface, "ServicesChanged", + _manager_services_changed, cm); + edbus_proxy_signal_handler_add(cm->technology_iface, "PropertyChanged", + _manager_wifi_prop_changed, cm); /* * PropertyChanged signal in service's path is guaranteed to arrive only * 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, + "GetServices", + _manager_get_services_cb, cm, + -1, ""); + edbus_proxy_call(cm->manager_iface, "GetProperties", _manager_get_prop_cb, cm, + -1, ""); + cm->pending.get_wifi_properties = edbus_proxy_call(cm->technology_iface, + "GetProperties", + _manager_get_wifi_prop_cb, + cm, -1, ""); - cm->pending.get_services = e_dbus_message_send(conn, msg_services, - _manager_get_services_cb, - -1, cm); - cm->pending.get_properties = e_dbus_message_send(conn, msg_props, - _manager_get_prop_cb, - -1, cm); - cm->pending.get_wifi_properties = e_dbus_message_send(conn, msg_wifi_props, - _manager_get_wifi_prop_cb, - -1, cm); return cm; } static inline void _e_connman_system_name_owner_exit(void) { - _manager_agent_unregister(); + if (!connman_manager) + return; + _manager_agent_unregister(connman_manager); econnman_mod_manager_inout(NULL); _manager_free(connman_manager); connman_manager = NULL; - free(bus_owner); - bus_owner = NULL; - ecore_event_add(E_CONNMAN_EVENT_MANAGER_OUT, NULL, NULL, NULL); } static inline void _e_connman_system_name_owner_enter(const char *owner) { - bus_owner = strdup(owner); connman_manager = _manager_new(); _manager_agent_register(connman_manager); ecore_event_add(E_CONNMAN_EVENT_MANAGER_IN, NULL, NULL, NULL); econnman_mod_manager_inout(connman_manager); } -static void _e_connman_system_name_owner_changed(void *data, DBusMessage *msg) -{ - const char *name, *from, *to; - DBusError err; - - 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; - } - - if (strcmp(name, CONNMAN_BUS_NAME) != 0) - return; - - DBG("NameOwnerChanged %s from=[%s] to=[%s]", name, from, to); - - if (from[0] == '\0' && to[0] != '\0') - _e_connman_system_name_owner_enter(to); - else if (from[0] != '\0' && to[0] == '\0') - _e_connman_system_name_owner_exit(); - else - ERR("unknow change from %s to %s", from, to); -} - static void -_e_connman_get_name_owner(void *data, DBusMessage *msg, DBusError *err) +_e_connman_system_name_owner_changed(void *data, const char *bus, const char *from, const char *to) { - const char *owner; - - pending_get_name_owner = NULL; - - /* Do nothing if already received a signal */ - if (bus_owner) - return; - - DBG("get_name_owner msg=%p", msg); - - if (dbus_error_is_set(err)) - { - if (strcmp(err->name, DBUS_ERROR_NAME_HAS_NO_OWNER) != 0) - ERR("could not get bus name owner: %s %s", err->name, err->message); - return; - } - - if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &owner, - DBUS_TYPE_INVALID)) - { - ERR("Could not get name owner"); - return; - } - - _e_connman_system_name_owner_enter(owner); + if (to[0]) + _e_connman_system_name_owner_enter(to); + else + _e_connman_system_name_owner_exit(); } /** @@ -1039,7 +811,7 @@ _e_connman_get_name_owner(void *data, DBusMessage *msg, DBusError *err) * - E_CONNMAN_EVENT_MANAGER_OUT: issued when connman connection is lost. */ unsigned int -e_connman_system_init(E_DBus_Connection *edbus_conn) +e_connman_system_init(EDBus_Connection *edbus_conn) { init_count++; @@ -1050,14 +822,9 @@ e_connman_system_init(E_DBus_Connection *edbus_conn) E_CONNMAN_EVENT_MANAGER_OUT = ecore_event_type_new(); conn = edbus_conn; - handler_name_owner = e_dbus_signal_handler_add(conn, - E_DBUS_FDO_BUS, E_DBUS_FDO_PATH, E_DBUS_FDO_INTERFACE, - "NameOwnerChanged", _e_connman_system_name_owner_changed, - NULL); - pending_get_name_owner = e_dbus_get_name_owner(conn, - CONNMAN_BUS_NAME, _e_connman_get_name_owner, - NULL); - + edbus_name_owner_changed_callback_add(conn, CONNMAN_BUS_NAME, + _e_connman_system_name_owner_changed, + NULL, EINA_TRUE); agent = econnman_agent_new(edbus_conn); return init_count; @@ -1082,13 +849,14 @@ e_connman_system_shutdown(void) if (init_count > 0) return init_count; - e_dbus_signal_handler_del(conn, handler_name_owner); - if (pending_get_name_owner) - dbus_pending_call_cancel(pending_get_name_owner); - + edbus_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); agent = NULL; conn = NULL; diff --git a/src/modules/connman/e_mod_main.c b/src/modules/connman/e_mod_main.c index db3fa1e29..c9267fb55 100644 --- a/src/modules/connman/e_mod_main.c +++ b/src/modules/connman/e_mod_main.c @@ -110,7 +110,7 @@ _econnman_popup_selected_cb(void *data) return; cs = econnman_manager_find_service(inst->ctxt->cm, path); - if (cs == NULL) + if (!cs) return; switch (cs->state) @@ -148,7 +148,7 @@ _econnman_popup_update(struct Connman_Manager *cm, E_Connman_Instance *inst) Evas_Object *end = _econnman_service_new_end(cs, evas); e_widget_ilist_append_full(list, icon, end, cs->name ?: hidden, _econnman_popup_selected_cb, - inst, cs->obj.path); + inst, cs->path); } e_widget_ilist_thaw(list); @@ -649,7 +649,7 @@ EAPI void * e_modapi_init(E_Module *m) { E_Connman_Module_Context *ctxt; - E_DBus_Connection *c; + EDBus_Connection *c; if (_e_connman_log_dom < 0) { @@ -665,8 +665,8 @@ e_modapi_init(E_Module *m) ctxt = E_NEW(E_Connman_Module_Context, 1); if (!ctxt) goto error_connman_context; - - c = e_dbus_bus_get(DBUS_BUS_SYSTEM); + edbus_init(); + c = edbus_connection_get(EDBUS_CONNECTION_TYPE_SYSTEM); if (!c) goto error_dbus_bus_get; if (!e_connman_system_init(c)) @@ -681,6 +681,7 @@ e_modapi_init(E_Module *m) return ctxt; error_connman_system_init: + edbus_connection_unref(c); error_dbus_bus_get: E_FREE(ctxt); error_connman_context: @@ -712,6 +713,7 @@ e_modapi_shutdown(E_Module *m) return 0; e_connman_system_shutdown(); + edbus_shutdown(); _econnman_instances_free(ctxt); _econnman_configure_registry_unregister(); diff --git a/src/modules/connman/e_mod_main.h b/src/modules/connman/e_mod_main.h index 29dcae497..bac950843 100644 --- a/src/modules/connman/e_mod_main.h +++ b/src/modules/connman/e_mod_main.h @@ -63,7 +63,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(E_DBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); +E_Connman_Agent *econnman_agent_new(EDBus_Connection *edbus_conn) EINA_ARG_NONNULL(1); void econnman_agent_del(E_Connman_Agent *agent); /**