kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ecore_con: use Eina_Future for Efl.Net.Control.Technology.

This commit is contained in:
Cedric BAIL 2017-12-11 15:03:11 -08:00
parent 6e446c64d6
commit a8197a8c40
4 changed files with 52 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/examples/ecore/efl_net_control_example.c
View File

@ -698,22 +698,28 @@ _cmd_technology_show(Eo *ctl, size_t argc EINA_UNUSED, char **argv)
_technology_print(tech);
}
static void
_technology_scan_done(void *data, const Efl_Event *event EINA_UNUSED)
static Eina_Value
_technology_scan_done(void *data, const Eina_Value v,
const Eina_Future *dead EINA_UNUSED)
{
Eo *tech = data;
printf("INFO: technology '%s' finished scan.\n",
efl_net_control_technology_name_get(tech));
}
static void
_technology_scan_error(void *data, const Efl_Event *event)
{
Eo *tech = data;
Efl_Future_Event_Failure *f = event->info;
printf("INFO: technology '%s' could not scan: %s\n",
efl_net_control_technology_name_get(tech),
eina_error_msg_get(f->error));
if (v.type == EINA_VALUE_TYPE_ERROR)
{
Eina_Error err = 0;
eina_value_error_get(&v, &err);
printf("INFO: technology '%s' could not scan: %s\n",
efl_net_control_technology_name_get(tech),
eina_error_msg_get(err));
}
else
{
printf("INFO: technology '%s' finished scan.\n",
efl_net_control_technology_name_get(tech));
}
return v;
}
static void
@ -722,11 +728,8 @@ _cmd_technology_scan(Eo *ctl, size_t argc EINA_UNUSED, char **argv)
Eo *tech = _technology_find(ctl, argv[1]);
if (!tech) return;
printf("INFO: started scan on technology '%s'\n", argv[1]);
efl_future_then(efl_net_control_technology_scan(tech),
_technology_scan_done,
_technology_scan_error,
NULL,
tech);
eina_future_then(efl_net_control_technology_scan(tech),
_technology_scan_done, tech);
}
static void

45
src/lib/ecore_con/efl_net_control_technology-connman.c
View File

@ -347,15 +347,14 @@ _efl_net_control_technology_type_get(Eo *o EINA_UNUSED, Efl_Net_Control_Technolo
static void
_efl_net_control_technology_scan_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
Efl_Promise *promise = data;
Eo *o = efl_parent_get(promise);
Eina_Promise *promise = data;
Eo *o = eldbus_pending_data_get(eina_promise_data_get(promise), ".object");
Efl_Net_Control_Technology_Data *pd = efl_data_scope_get(o, MY_CLASS);
const char *err_name, *err_msg;
EINA_SAFETY_ON_NULL_RETURN(pd);
pd->pending = eina_list_remove(pd->pending, pending);
efl_key_data_set(promise, "eldbus_pending", NULL);
if (eldbus_message_error_get(msg, &err_name, &err_msg))
{
Eina_Error err = EINVAL;
@ -364,24 +363,28 @@ _efl_net_control_technology_scan_cb(void *data, const Eldbus_Message *msg, Eldbu
err = ENOTSUP;
WRN("Could not Scan %p: %s=%s", o, err_name, err_msg);
efl_promise_failed_set(promise, err);
eina_promise_reject(promise, err);
return;
}
efl_promise_value_set(promise, o, NULL);
efl_del(promise);
eina_promise_resolve(promise, eina_value_object_init(o));
}
static void
_efl_net_control_technology_scan_promise_del(void *data, const Efl_Event *event)
_efl_net_control_technology_scan_promise_del(void *data, const Eina_Promise *dead_ptr)
{
Eldbus_Pending *p;
Eo *o = data;
Efl_Net_Control_Technology_Data *pd = efl_data_scope_get(o, MY_CLASS);
Eldbus_Pending *p = data;
Efl_Net_Control_Technology_Data *pd;
Eo *o;
if (!p) return ;
o = eldbus_pending_data_get(p, ".object");
pd = efl_data_scope_get(o, MY_CLASS);
EINA_SAFETY_ON_NULL_RETURN(pd);
p = efl_key_data_get(event->object, "eldbus_pending");
p = eina_promise_data_get(dead_ptr);
if (!p) return; /* already gone, nothing to do */
pd->pending = eina_list_remove(pd->pending, p);
@ -389,28 +392,32 @@ _efl_net_control_technology_scan_promise_del(void *data, const Efl_Event *event)
eldbus_pending_cancel(p);
}
EOLIAN static Efl_Future *
EOLIAN static Eina_Future *
_efl_net_control_technology_scan(Eo *o, Efl_Net_Control_Technology_Data *pd)
{
Eldbus_Pending *p;
Efl_Promise *promise;
Eina_Promise *promise;
Eina_Future *f = NULL;
promise = efl_add(EFL_PROMISE_CLASS, o,
efl_event_callback_add(efl_added, EFL_EVENT_DEL, _efl_net_control_technology_scan_promise_del, o));
promise = eina_promise_new(efl_loop_future_scheduler_get(o),
_efl_net_control_technology_scan_promise_del, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(promise, NULL);
f = eina_future_new(promise);
p = eldbus_proxy_call(pd->proxy, "Scan",
_efl_net_control_technology_scan_cb, promise, -1.0, "");
EINA_SAFETY_ON_NULL_GOTO(p, error_dbus);
pd->pending = eina_list_append(pd->pending, p);
efl_key_data_set(promise, "eldbus_pending", p);
eina_promise_data_set(promise, p);
eldbus_pending_data_set(p, ".object", o);
return efl_promise_future_get(promise);
return efl_future_Eina_FutureXXX_then(o, f);
error_dbus:
efl_promise_failed_set(promise, ENOSYS);
return promise;
eina_promise_reject(promise, ENOSYS);
return efl_future_Eina_FutureXXX_then(o, f);
}
const char *

7
src/lib/ecore_con/efl_net_control_technology-none.c
View File

@ -56,10 +56,11 @@ _efl_net_control_technology_type_get(Eo *obj EINA_UNUSED, Efl_Net_Control_Techno
return 0;
}
EOLIAN static Efl_Future *
_efl_net_control_technology_scan(Eo *obj EINA_UNUSED, Efl_Net_Control_Technology_Data *pd EINA_UNUSED)
EOLIAN static Eina_Future *
_efl_net_control_technology_scan(Eo *obj, Efl_Net_Control_Technology_Data *pd EINA_UNUSED)
{
return NULL;
return eina_future_rejected(efl_loop_future_scheduler_get(obj),
EINA_ERROR_NOT_IMPLEMENTED);
}
#include "efl_net_control_technology.eo.c"

2
src/lib/ecore_con/efl_net_control_technology.eo
View File

@ -96,7 +96,7 @@ class Efl.Net.Control.Technology (Efl.Loop_User) {
state. Otherwise prefer to let the system passively do
scans in a timely manner.
]]
return: future<void_ptr>; [[Future return for finished background scan]] /* NOTE: This should be future<void> */
return: ptr(Eina.Future) @owned; [[Future return for finished background scan]] /* NOTE: This should be future<void> */
}
}