path: root/src/lib/eldbus/eldbus_model_proxy.c

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "eldbus_model_proxy_private.h"
#include "eldbus_model_private.h"

#include <Eina.h>

#define MY_CLASS ELDBUS_MODEL_PROXY_CLASS
#define MY_CLASS_NAME "Eldbus_Model_Proxy"

static void _eldbus_model_proxy_efl_model_base_properties_load(Eo *, Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_efl_model_base_children_load(Eo *, Eldbus_Model_Proxy_Data *);
static bool _eldbus_model_proxy_load(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_unload(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_property_get_all_cb(void *, const Eldbus_Message *, Eldbus_Pending *);
static void _eldbus_model_proxy_property_set_cb(void *, const Eldbus_Message *, Eldbus_Pending *);
static void _eldbus_model_proxy_start_monitor(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_stop_monitor(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_property_changed_cb(void *, Eldbus_Proxy *, void *);
static void _eldbus_model_proxy_property_invalidated_cb(void *, Eldbus_Proxy *, void *);
static bool _eldbus_model_proxy_is_property_writeable(Eldbus_Model_Proxy_Data *, const char *);
static bool _eldbus_model_proxy_is_property_readable(Eldbus_Model_Proxy_Data *, const char *);
static const char *_eldbus_model_proxy_property_type_get(Eldbus_Model_Proxy_Data *, const char *);
static void _eldbus_model_proxy_create_methods_children(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_create_signals_children(Eldbus_Model_Proxy_Data *);
static void _eldbus_model_proxy_member_setup_cb(void *data, int index, Eina_Value_Struct_Member *member);

typedef struct _Eldbus_Model_Proxy_Property_Set_Data Eldbus_Model_Proxy_Property_Set_Data;

struct _Eldbus_Model_Proxy_Property_Set_Data
{
   Eldbus_Model_Proxy_Data *pd;
   Eina_Stringshare *property;
   Eina_Value value;
};

static Eldbus_Model_Proxy_Property_Set_Data * _eldbus_model_proxy_property_set_data_new(Eldbus_Model_Proxy_Data *, const char *, Eina_Value *);
static void _eldbus_model_proxy_property_set_data_free(Eldbus_Model_Proxy_Property_Set_Data *);

static Eo_Base*
_eldbus_model_proxy_eo_base_constructor(Eo *obj, Eldbus_Model_Proxy_Data *pd)
{
   WRN("_eldbus_model_proxy_eo_base_constructor (%p)", obj);
   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
   WRN("_eldbus_model_proxy_eo_base_constructor (%p) 2", obj);

   pd->obj = obj;
   pd->load.status = EFL_MODEL_LOAD_STATUS_UNLOADED;
   pd->object = NULL;
   pd->proxy = NULL;
   pd->properties_array = NULL;
   pd->properties_desc = NULL;
   pd->properties = NULL;
   pd->children_list = NULL;
   pd->name = NULL;
   pd->pending_list = NULL;
   pd->monitoring = false;
   pd->interface = NULL;
   return obj;
}

static void
_eldbus_model_proxy_constructor(Eo *obj EINA_UNUSED,
                                Eldbus_Model_Proxy_Data *pd,
                                Eldbus_Object *object,
                                const Eldbus_Introspection_Interface *interface)
{
   DBG("(%p)", obj);
   EINA_SAFETY_ON_NULL_RETURN(object);
   EINA_SAFETY_ON_NULL_RETURN(interface);

   pd->object = eldbus_object_ref(object);
   pd->name = eina_stringshare_add(interface->name);
   pd->interface = interface;
}

static void
_eldbus_model_proxy_eo_base_destructor(Eo *obj, Eldbus_Model_Proxy_Data *pd)
{
   DBG("(%p)", obj);

   _eldbus_model_proxy_unload(pd);

   eina_value_free(pd->properties);
   efl_model_value_struct_desc_free(pd->properties_desc);

   eina_stringshare_del(pd->name);
   eldbus_object_unref(pd->object);

   eo_do_super(obj, MY_CLASS, eo_destructor());
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_properties_get(Eo *obj EINA_UNUSED,
                                               Eldbus_Model_Proxy_Data *pd,
                                               Eina_Array * const* properties_array)
{
   DBG("(%p)", obj);
   EINA_SAFETY_ON_NULL_RETURN_VAL(pd, EFL_MODEL_LOAD_STATUS_ERROR);
   EINA_SAFETY_ON_NULL_RETURN_VAL(pd->obj, EFL_MODEL_LOAD_STATUS_ERROR);

   if (!(pd->load.status & EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES))
     {
        WRN("%s", "Properties not loaded.");
        return EMODEL_LOAD_STATUS_ERROR;
     }

   *(Eina_Array**)properties_array = pd->properties_array;
   return pd->load.status;
}

static void
_eldbus_model_proxy_efl_model_base_properties_load(Eo *obj, Eldbus_Model_Proxy_Data *pd)
{
   DBG("(%p)", obj);

   if (pd->load.status & EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES)
     return;

   if (!_eldbus_model_proxy_load(pd))
     return;

   const unsigned int properties_count = eina_list_count(pd->interface->properties);

   pd->properties_array = eina_array_new(properties_count);
   EINA_SAFETY_ON_NULL_RETURN(pd->properties_array);

   if (0 == properties_count)
     {
        efl_model_load_set(pd->obj, &pd->load, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
        return;
     }

   Eina_List *it;
   Eldbus_Introspection_Property *property;
   EINA_LIST_FOREACH(pd->interface->properties, it, property)
     {
        Eina_Stringshare *name = eina_stringshare_add(property->name);
        EINA_SAFETY_ON_NULL_RETURN(name);

        Eina_Bool ret = eina_array_push(pd->properties_array, name);
        EINA_SAFETY_ON_FALSE_RETURN(ret);
     }

   Eldbus_Pending *pending = eldbus_proxy_property_get_all(pd->proxy, _eldbus_model_proxy_property_get_all_cb, pd);
   pd->pending_list = eina_list_append(pd->pending_list, pending);

   efl_model_load_set(pd->obj, &pd->load, EFL_MODEL_LOAD_STATUS_LOADING_PROPERTIES);
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_property_set(Eo *obj EINA_UNUSED,
                                        Eldbus_Model_Proxy_Data *pd,
                                        const char *property,
                                        Eina_Value const* value)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(property, EFL_MODEL_LOAD_STATUS_ERROR);
   DBG("(%p): property=%s", obj, property);

   ERR("proxy property get commented");

   if (!_eldbus_model_proxy_is_property_writeable(pd, property))
     {
        WRN("Property is read-only: %s", property);
        return EFL_MODEL_LOAD_STATUS_ERROR;
     }

   Eldbus_Model_Proxy_Property_Set_Data *data =
     _eldbus_model_proxy_property_set_data_new(pd, property, (Eina_Value*)value);
   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EFL_MODEL_LOAD_STATUS_ERROR);

   const char *signature = _eldbus_model_proxy_property_type_get(pd, property);
   EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EFL_MODEL_LOAD_STATUS_ERROR);

   Eldbus_Pending *pending = eldbus_proxy_property_value_set
     (pd->proxy, property, signature, (Eina_Value*)value, _eldbus_model_proxy_property_set_cb, data);
   pd->pending_list = eina_list_append(pd->pending_list, pending);

   return pd->load.status;
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_property_get(Eo *obj EINA_UNUSED,
                                        Eldbus_Model_Proxy_Data *pd,
                                        const char *property,
                                        Eina_Value const **value)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(property, EFL_MODEL_LOAD_STATUS_ERROR);
   EINA_SAFETY_ON_NULL_RETURN_VAL(value, EFL_MODEL_LOAD_STATUS_ERROR);
   WRN("(%p): property=%s", obj, property);

   if (!(pd->load.status & EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES))
     return EFL_MODEL_LOAD_STATUS_ERROR;

   if (!_eldbus_model_proxy_is_property_readable(pd, property))
     {
        WRN("Property is write-only: %s", property);
        return EFL_MODEL_LOAD_STATUS_ERROR;
     }

   WRN("\n");

   Eina_Bool ret = eina_value_struct_value_get(pd->properties, property, &pd->tmp_value);
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ret, EFL_MODEL_LOAD_STATUS_ERROR);

   WRN("\n");

   *value = &pd->tmp_value;

   WRN("\n");
   
   return pd->load.status;
}

static void
_eldbus_model_proxy_efl_model_base_load(Eo *obj EINA_UNUSED, Eldbus_Model_Proxy_Data *pd)
{
   WRN("(%p)", obj);

   if (!_eldbus_model_proxy_load(pd))
     return;

   WRN("(%p)", obj);

   _eldbus_model_proxy_efl_model_base_properties_load(obj, pd);
   WRN("(%p)", obj);
   _eldbus_model_proxy_efl_model_base_children_load(obj, pd);
   WRN("(%p)", obj);
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_load_status_get(Eo *obj EINA_UNUSED, Eldbus_Model_Proxy_Data *pd)
{
   DBG("(%p)", obj);
   return pd->load.status;
}

static void
_eldbus_model_proxy_efl_model_base_unload(Eo *obj EINA_UNUSED, Eldbus_Model_Proxy_Data *pd)
{
   DBG("(%p)", obj);

   _eldbus_model_proxy_unload(pd);

   efl_model_load_set(pd->obj, &pd->load, EFL_MODEL_LOAD_STATUS_UNLOADED);
}

Eo *
_eldbus_model_proxy_efl_model_base_child_add(Eo *obj EINA_UNUSED, Eldbus_Model_Proxy_Data *pd EINA_UNUSED)
{
   DBG("(%p)", obj);
   return NULL;
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_child_del(Eo *obj EINA_UNUSED,
                                     Eldbus_Model_Proxy_Data *pd EINA_UNUSED,
                                     Eo *child EINA_UNUSED)
{
   DBG("(%p)", obj);
   return EFL_MODEL_LOAD_STATUS_ERROR;
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_children_slice_get(Eo *obj EINA_UNUSED,
                                              Eldbus_Model_Proxy_Data *pd,
                                              unsigned start,
                                              unsigned count,
                                              Eina_Accessor **children_accessor)
{
   fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
   WRN("(%p)", obj);
   fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);

   if (!(pd->load.status & EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN))
     {
        WRN("(%p): Children not loaded", obj);
        *children_accessor = NULL;
        return pd->load.status;
     }

   *children_accessor = efl_model_list_slice(pd->children_list, start, count);
   return pd->load.status;
}

static Efl_Model_Load_Status
_eldbus_model_proxy_efl_model_base_children_count_get(Eo *obj EINA_UNUSED,
                                              Eldbus_Model_Proxy_Data *pd,
                                              unsigned *children_count)
{
   DBG("(%p)", obj);
   *children_count = eina_list_count(pd->children_list);
   return pd->load.status;
}

static void
_eldbus_model_proxy_efl_model_base_children_load(Eo *obj, Eldbus_Model_Proxy_Data *pd)
{
   WRN("\n");

   if (pd->load.status & EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN)
     return;
   WRN("\n");

   if (!_eldbus_model_proxy_load(pd))
     return;
   WRN("\n");

   _eldbus_model_proxy_create_methods_children(pd);
   WRN("\n");
   _eldbus_model_proxy_create_signals_children(pd);
   WRN("\n");

   efl_model_load_set(pd->obj, &pd->load, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
   WRN("\n");

   unsigned int count = eina_list_count(pd->children_list);
   WRN("\n");
   if (count)
     eo_do(pd->obj, eo_event_callback_call(EFL_MODEL_BASE_EVENT_CHILDREN_COUNT_CHANGED, &count));
   WRN("\n");
}

static void
_eldbus_model_proxy_create_methods_children(Eldbus_Model_Proxy_Data *pd)
{
   WRN("\n");
   Eina_List *it;
   WRN("\n");
   Eldbus_Introspection_Method *method;
   WRN("\n");
   EINA_LIST_FOREACH(pd->interface->methods, it, method)
     {
   WRN("\n");
        const char *bus = eldbus_object_bus_name_get(pd->object);
        EINA_SAFETY_ON_NULL_RETURN(bus);
   WRN("\n");

        const char *path = eldbus_object_path_get(pd->object);
        EINA_SAFETY_ON_NULL_RETURN(path);
   WRN("\n");

        const char *interface_name = pd->interface->name;
        EINA_SAFETY_ON_NULL_RETURN(interface_name);
   WRN("\n");

        const char *method_name = method->name;
        EINA_SAFETY_ON_NULL_RETURN(method_name);
   WRN("\n");

        INF("(%p) Creating method child: bus = %s, path = %s, method = %s::%s", pd->obj, bus, path, interface_name, method_name);
   WRN("\n");

        Eo *child = eo_add(ELDBUS_MODEL_METHOD_CLASS, NULL,
                           eldbus_model_method_constructor(pd->proxy, method));
   WRN("\n");

        pd->children_list = eina_list_append(pd->children_list, child);
   WRN("\n");
     }
   WRN("\n");
}

static void
_eldbus_model_proxy_create_signals_children(Eldbus_Model_Proxy_Data *pd)
{
   Eina_List *it;
   Eldbus_Introspection_Signal *signal;
   EINA_LIST_FOREACH(pd->interface->signals, it, signal)
     {
        const char *bus = eldbus_object_bus_name_get(pd->object);
        EINA_SAFETY_ON_NULL_RETURN(bus);

        const char *path = eldbus_object_path_get(pd->object);
        EINA_SAFETY_ON_NULL_RETURN(path);

        const char *interface_name = pd->interface->name;
        EINA_SAFETY_ON_NULL_RETURN(interface_name);

        const char *signal_name = signal->name;
        EINA_SAFETY_ON_NULL_RETURN(signal_name);

        DBG("(%p) Creating signal child: bus = %s, path = %s, signal = %s::%s", pd->obj, bus, path, interface_name, signal_name);

        Eo *child = eo_add(ELDBUS_MODEL_SIGNAL_CLASS, NULL,
                           eldbus_model_signal_constructor(pd->proxy, signal));

        pd->children_list = eina_list_append(pd->children_list, child);
     }
}

static const char *
_eldbus_model_proxy_name_get(Eo *obj EINA_UNUSED, Eldbus_Model_Proxy_Data *pd)
{
   return pd->name;
}

static bool
_eldbus_model_proxy_load(Eldbus_Model_Proxy_Data *pd)
{
   WRN("\n");
   EINA_SAFETY_ON_NULL_RETURN_VAL(pd, false);
   if (pd->proxy)
     return true;

   WRN("\n");
   pd->proxy = eldbus_proxy_get(pd->object, pd->name);
   WRN("\n");
   if (!pd->proxy)
     {
        ERR("Cannot get proxy for interface: %s", pd->name);
        return false;
     }
   WRN("\n");

   return true;
}

static void
_eldbus_model_proxy_unload(Eldbus_Model_Proxy_Data *pd)
{
   EINA_SAFETY_ON_NULL_RETURN(pd);

   Eo *child;
   EINA_LIST_FREE(pd->children_list, child)
     eo_unref(child);

   Eldbus_Pending *pending;
   EINA_LIST_FREE(pd->pending_list, pending)
     eldbus_pending_cancel(pending);

   if (pd->properties_array)
     {
        unsigned int i;
        Eina_Stringshare *property;
        Eina_Array_Iterator it;
        EINA_ARRAY_ITER_NEXT(pd->properties_array, i, property, it)
          eina_stringshare_del(property);
        eina_array_free(pd->properties_array);
        pd->properties_array = NULL;
     }

   eina_value_free(pd->properties);
   pd->properties = NULL;

   _eldbus_model_proxy_stop_monitor(pd);

   if (pd->proxy)
     {
        eldbus_proxy_unref(pd->proxy);
        pd->proxy = NULL;
     }
}

static void
_eldbus_model_proxy_start_monitor(Eldbus_Model_Proxy_Data *pd)
{
   if (pd->monitoring)
     return;
   pd->monitoring = true;

   eldbus_proxy_event_callback_add(pd->proxy,
                                   ELDBUS_PROXY_EVENT_PROPERTY_CHANGED,
                                   _eldbus_model_proxy_property_changed_cb,
                                   pd);

   eldbus_proxy_event_callback_add(pd->proxy,
                                   ELDBUS_PROXY_EVENT_PROPERTY_REMOVED,
                                   _eldbus_model_proxy_property_invalidated_cb,
                                   pd);
}

static void
_eldbus_model_proxy_stop_monitor(Eldbus_Model_Proxy_Data *pd)
{
   if (!pd->monitoring)
     return;
   pd->monitoring = false;

   eldbus_proxy_event_callback_del(pd->proxy,
                                   ELDBUS_PROXY_EVENT_PROPERTY_CHANGED,
                                   _eldbus_model_proxy_property_changed_cb,
                                   pd);

   eldbus_proxy_event_callback_del(pd->proxy,
                                   ELDBUS_PROXY_EVENT_PROPERTY_REMOVED,
                                   _eldbus_model_proxy_property_invalidated_cb,
                                   pd);
}

static void
_eldbus_model_proxy_property_changed_cb(void *data,
                                        Eldbus_Proxy *proxy EINA_UNUSED,
                                        void *event_info)
{
   Eldbus_Model_Proxy_Data *pd = (Eldbus_Model_Proxy_Data*)data;
   DBG("(%p)", pd->obj);

   Eldbus_Object_Event_Property_Changed *event = (Eldbus_Object_Event_Property_Changed*)event_info;

   Eina_Bool ret = eina_value_struct_value_set(pd->properties, event->name, event->value);
   EINA_SAFETY_ON_FALSE_RETURN(ret);

   Efl_Model_Property_Event evt = {.changed_properties = pd->properties_array};
   eo_do(pd->obj, eo_event_callback_call(EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED, &evt));
}

static void
_eldbus_model_proxy_property_invalidated_cb(void *data,
                                            Eldbus_Proxy *proxy EINA_UNUSED,
                                            void *event_info)
{
   Eldbus_Model_Proxy_Data *pd = (Eldbus_Model_Proxy_Data*)data;
   DBG("(%p)", pd->obj);

   Eldbus_Proxy_Event_Property_Changed *event = (Eldbus_Proxy_Event_Property_Changed*)event_info;

   // TODO: eldbus_proxy_property_get(event->name) ?

<<<<<<< HEAD
   Efl_Model_Property_Event evt = {0};
=======
   Emodel_Property_Event evt = {0};
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
   evt.invalidated_properties = eina_array_new(1);
   EINA_SAFETY_ON_NULL_RETURN(evt.invalidated_properties);

   Eina_Bool ret = eina_array_push(evt.invalidated_properties, event->name);
   EINA_SAFETY_ON_FALSE_GOTO(ret, on_error);

on_error:
   eina_array_free(evt.invalidated_properties);
}

static void
_eldbus_model_proxy_property_get_all_cb(void *data,
                                        const Eldbus_Message *msg,
                                        Eldbus_Pending *pending)
{
   Eldbus_Model_Proxy_Data *pd = (Eldbus_Model_Proxy_Data*)data;
   WRN("(%p)", pd->obj);

   pd->pending_list = eina_list_remove(pd->pending_list, pending);

   const char *error_name, *error_text;
   if (eldbus_message_error_get(msg, &error_name, &error_text))
     {
        ERR("%s: %s", error_name, error_text);
        efl_model_error_notify(pd->obj);
        return;
     }

   Eldbus_Message_Iter *values = NULL;
   if (!eldbus_message_arguments_get(msg, "a{sv}", &values))
     {
        ERR("%s", "Error getting arguments.");
        return;
     }

   if (!pd->properties_desc)
     {
<<<<<<< HEAD
        pd->properties_desc = efl_model_value_struct_desc_new(
=======
        pd->properties_desc = emodel_value_struct_desc_new(
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
          eina_list_count(pd->interface->properties),
          _eldbus_model_proxy_member_setup_cb,
          pd);
     }
<<<<<<< HEAD
   EINA_SAFETY_ON_TRUE_RETURN(pd->properties);
=======
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
   pd->properties = eina_value_struct_new(pd->properties_desc);

   bool changed = false;
   Eldbus_Message_Iter *entry;
   while (eldbus_message_iter_get_and_next(values, 'e', &entry))
     {
        const char *property;
        Eldbus_Message_Iter *variant;
        if (!eldbus_message_iter_arguments_get(entry, "sv", &property, &variant))
          continue;

        WRN("(%p): Adding property value: %s", pd->obj, property);

        Eina_Value *struct_value = eldbus_message_iter_struct_like_to_eina_value(variant);
        EINA_SAFETY_ON_NULL_RETURN(struct_value);

        Eina_Value arg0;
        Eina_Bool ret = eina_value_struct_value_get(struct_value, "arg0", &arg0);
        eina_value_free(struct_value);
        EINA_SAFETY_ON_FALSE_RETURN(ret);

<<<<<<< HEAD
        fprintf(stderr, "arg0: %s\n", eina_value_to_string(&arg0));
        
=======
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
        ret = eina_value_struct_value_set(pd->properties, property, &arg0);
        eina_value_flush(&arg0);
        EINA_SAFETY_ON_FALSE_RETURN(ret);

        changed = true;
     }

   _eldbus_model_proxy_start_monitor(pd);

   if (changed)
     {
<<<<<<< HEAD
        Efl_Model_Property_Event evt = {.changed_properties = pd->properties_array};
        eo_do(pd->obj, eo_event_callback_call(EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED, &evt));
     }

   efl_model_load_set(pd->obj, &pd->load, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
=======
        Emodel_Property_Event evt = {.changed_properties = pd->properties};
        eo_do(pd->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt));
     }

   emodel_load_set(pd->obj, &pd->load, EMODEL_LOAD_STATUS_LOADED_PROPERTIES);
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
}


static void
_eldbus_model_proxy_property_set_cb(void *data,
                                    const Eldbus_Message *msg,
                                    Eldbus_Pending *pending)
{
   Eldbus_Model_Proxy_Property_Set_Data *property_set_data = (Eldbus_Model_Proxy_Property_Set_Data *)data;
   Eldbus_Model_Proxy_Data *pd = property_set_data->pd;
   WRN("(%p)", pd->obj);

   pd->pending_list = eina_list_remove(pd->pending_list, pending);

   const char *error_name, *error_text;
   if (eldbus_message_error_get(msg, &error_name, &error_text))
     {
        ERR("%s: %s", error_name, error_text);
<<<<<<< HEAD
        efl_model_error_notify(pd->obj);
=======
        emodel_error_notify(pd->obj);
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.
        goto on_error;
     }

   Eina_Bool ret = eina_value_struct_value_set(pd->properties,
                                               property_set_data->property,
                                               &property_set_data->value);
   EINA_SAFETY_ON_FALSE_GOTO(ret, on_error);

<<<<<<< HEAD
   Efl_Model_Property_Event evt = {.changed_properties = pd->properties_array};
   eo_do(pd->obj, eo_event_callback_call(EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED, &evt));
=======
   Emodel_Property_Event evt = {.changed_properties = pd->properties};
   eo_do(pd->obj, eo_event_callback_call(EMODEL_EVENT_PROPERTIES_CHANGED, &evt));
>>>>>>> 0bf80ad... Emodel API changes: Emodel_Property_Event::changed_properties as Eina_Value now.

on_error:
   _eldbus_model_proxy_property_set_data_free(property_set_data);
}

static bool
_eldbus_model_proxy_is_property_writeable(Eldbus_Model_Proxy_Data *pd, const char *property)
{
   Eldbus_Introspection_Property *property_introspection =
     eldbus_introspection_property_find(pd->interface->properties, property);
   if (NULL == property_introspection)
     {
        WRN("Property not found: %s", property);
        return false;
     }

   return ELDBUS_INTROSPECTION_PROPERTY_ACCESS_WRITE == property_introspection->access
       || ELDBUS_INTROSPECTION_PROPERTY_ACCESS_READWRITE == property_introspection->access;
}

static bool
_eldbus_model_proxy_is_property_readable(Eldbus_Model_Proxy_Data *pd, const char *property)
{
   Eldbus_Introspection_Property *property_introspection =
     eldbus_introspection_property_find(pd->interface->properties, property);
   if (NULL == property_introspection)
     {
        WRN("Property not found: %s", property);
        return false;
     }

   return ELDBUS_INTROSPECTION_PROPERTY_ACCESS_READ == property_introspection->access
       || ELDBUS_INTROSPECTION_PROPERTY_ACCESS_READWRITE == property_introspection->access;
}

static const char *
_eldbus_model_proxy_property_type_get(Eldbus_Model_Proxy_Data *pd, const char *property)
{
   Eldbus_Introspection_Property *property_introspection =
     eldbus_introspection_property_find(pd->interface->properties, property);
   if (NULL == property_introspection)
     {
        WRN("Property not found: %s", property);
        return NULL;
     }

   return property_introspection->type;

}

static Eldbus_Model_Proxy_Property_Set_Data *
_eldbus_model_proxy_property_set_data_new(Eldbus_Model_Proxy_Data *pd,
                                          const char *property,
                                          Eina_Value *value)
{
   Eldbus_Model_Proxy_Property_Set_Data *data = calloc(1, sizeof(Eldbus_Model_Proxy_Property_Set_Data));
   EINA_SAFETY_ON_NULL_RETURN_VAL(data, NULL);

   data->pd = pd;
   data->property = eina_stringshare_add(property);
   Eina_Bool ret = eina_value_copy(value, &data->value);
   EINA_SAFETY_ON_FALSE_GOTO(ret, error);

   return data;

error:
   eina_stringshare_del(data->property);
   free(data);
   return NULL;
}

static void
_eldbus_model_proxy_property_set_data_free(Eldbus_Model_Proxy_Property_Set_Data *data)
{
   EINA_SAFETY_ON_NULL_RETURN(data);
   eina_stringshare_del(data->property);
   eina_value_flush(&data->value);
   free(data);
}

static void
_eldbus_model_proxy_member_setup_cb(void *data, int index, Eina_Value_Struct_Member *member)
{
   Eldbus_Model_Proxy_Data *pd = (Eldbus_Model_Proxy_Data*)data;

   member->name = eina_stringshare_ref(eina_array_data_get(pd->properties_array, index));

   Eldbus_Introspection_Property *property = eina_list_nth(pd->interface->properties, index);
   member->type = _dbus_type_to_eina_value_type(property->type[0]);
}

#include "eldbus_model_proxy.eo.c"