enlightenment
/
examples
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove efl_loop_main references, we should use our allocated loop

This commit is contained in:
Andy Williams 2018-01-04 19:28:26 +00:00
parent 5c4053942e
commit e9e0834b26
3 changed files with 35 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
reference/c/core/src/core_loop.c
View File

@ -122,10 +122,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
version = efl_loop_efl_version_get(loop); version = efl_loop_efl_version_get(loop);
printf("Running on EFL version %d.%d.%d [%s]\n\n", version->major, version->minor, printf("Running on EFL version %d.%d.%d [%s]\n\n", version->major, version->minor,
version->micro, version->build_id); version->micro, version->build_id);
_print_loop(loop, "Current"); _print_loop(loop, "Application");
loop = efl_loop_main_get(loop);
_print_loop(loop, "Application Main");
loop = efl_add(EFL_LOOP_CONSUMER_CLASS, loop, loop = efl_add(EFL_LOOP_CONSUMER_CLASS, loop,
efl_name_set(efl_added, "Loop Consumer")); efl_name_set(efl_added, "Loop Consumer"));

62
reference/c/eina/src/eina_future.c
View File

@ -17,10 +17,10 @@
* the promise is resolved, passing a value among them. * the promise is resolved, passing a value among them.
*/ */
static void _test1_simple_future(); static void _test1_simple_future(Efl_Loop *loop);
static void _test2_failed_future(); static void _test2_failed_future(Efl_Loop *loop);
static void _test3_cancelled_future(); static void _test3_cancelled_future(Efl_Loop *loop);
static void _test4_chained_future(); static void _test4_chained_future(Efl_Loop *loop);
/* ----------------------- Generic helper methods ---------------------- */ /* ----------------------- Generic helper methods ---------------------- */
@ -28,11 +28,10 @@ static void _test4_chained_future();
* This simple method prints the content of a value and passes it on. * This simple method prints the content of a value and passes it on.
*/ */
static Eina_Value static Eina_Value
_value_print(void *data, const Eina_Value value) _value_print(void *data EINA_UNUSED, const Eina_Value value)
{ {
Eina_Promise *promise = (Eina_Promise *)data;
char *str = eina_value_to_string(&value); char *str = eina_value_to_string(&value);
printf(" Success callback: Promise %p resolved to '%s'\n", promise, str); printf(" Success callback: Promise resolved to '%s'\n", str);
free(str); free(str);
return value; return value;
@ -53,8 +52,7 @@ _promise_cancel(void *data EINA_UNUSED, const Eina_Promise *dead EINA_UNUSED)
static Eina_Value static Eina_Value
_error_print(void *data EINA_UNUSED, const Eina_Error error) _error_print(void *data EINA_UNUSED, const Eina_Error error)
{ {
Eina_Promise *promise = (Eina_Promise *)data; printf(" Error callback: Promise encountered error '%s'\n",
printf(" Error callback: Promise %p encountered error '%s'\n", promise,
eina_error_msg_get(error)); eina_error_msg_get(error));
return EINA_VALUE_EMPTY; return EINA_VALUE_EMPTY;
@ -75,21 +73,21 @@ _test1_resolve(void *data, const Efl_Event *event)
/* Launches the next test */ /* Launches the next test */
static void static void
_test1_next_test(void *data EINA_UNUSED, const Eina_Future *dead_future EINA_UNUSED) _test1_next_test(void *data, const Eina_Future *dead_future EINA_UNUSED)
{ {
Efl_Loop *loop = data;
printf(" Test 1 finished\n"); printf(" Test 1 finished\n");
_test2_failed_future(); _test2_failed_future(loop);
} }
/* TEST 1: Set up a promised future and resolve it from a timer callback */ /* TEST 1: Set up a promised future and resolve it from a timer callback */
static void static void
_test1_simple_future() _test1_simple_future(Efl_Loop *loop)
{ {
Efl_Loop *loop;
Eina_Promise *promise; Eina_Promise *promise;
// Create a promise // Create a promise
loop = efl_loop_main_get(EFL_LOOP_CLASS);
promise = eina_promise_new(efl_loop_future_scheduler_get(loop), promise = eina_promise_new(efl_loop_future_scheduler_get(loop),
_promise_cancel, NULL); _promise_cancel, NULL);
printf("Test 1: Waiting for promise %p to be resolved...\n", promise); printf("Test 1: Waiting for promise %p to be resolved...\n", promise);
@ -99,7 +97,7 @@ _test1_simple_future()
eina_future_then_easy(eina_future_new(promise), eina_future_then_easy(eina_future_new(promise),
.success = _value_print, .success = _value_print,
.free = _test1_next_test, .free = _test1_next_test,
.data = promise); .data = loop);
// Set up a regular timer that will trigger after 1s. We use it to // Set up a regular timer that will trigger after 1s. We use it to
// simulate a delayed promise resolve. // simulate a delayed promise resolve.
@ -124,21 +122,21 @@ _test2_reject(void *data, const Efl_Event *event)
/* Launches the next test */ /* Launches the next test */
static void static void
_test2_next_test(void *data EINA_UNUSED, const Eina_Future *dead_future EINA_UNUSED) _test2_next_test(void *data, const Eina_Future *dead_future EINA_UNUSED)
{ {
Efl_Loop *loop = data;
printf(" Test 2 finished\n"); printf(" Test 2 finished\n");
_test3_cancelled_future(); _test3_cancelled_future(loop);
} }
/* TEST 2: Set up a promised future and reject it from a timer callback */ /* TEST 2: Set up a promised future and reject it from a timer callback */
static void static void
_test2_failed_future() _test2_failed_future(Efl_Loop *loop)
{ {
Efl_Loop *loop;
Eina_Promise *promise; Eina_Promise *promise;
// Create a promise // Create a promise
loop = efl_loop_main_get(EFL_LOOP_CLASS);
promise = eina_promise_new(efl_loop_future_scheduler_get(loop), promise = eina_promise_new(efl_loop_future_scheduler_get(loop),
_promise_cancel, NULL); _promise_cancel, NULL);
printf("Test 2: Waiting for promise %p to be rejected...\n", promise); printf("Test 2: Waiting for promise %p to be rejected...\n", promise);
@ -150,7 +148,7 @@ _test2_failed_future()
.success = _value_print, .success = _value_print,
.error = _error_print, .error = _error_print,
.free = _test2_next_test, .free = _test2_next_test,
.data = promise); .data = loop);
// Set up a regular timer that will trigger after 1s. We use it to // Set up a regular timer that will trigger after 1s. We use it to
// simulate a delayed promise rejection. // simulate a delayed promise rejection.
@ -164,22 +162,22 @@ _test2_failed_future()
/* Launches the next test */ /* Launches the next test */
static void static void
_test3_next_test(void *data EINA_UNUSED, const Eina_Future *dead_future EINA_UNUSED) _test3_next_test(void *data, const Eina_Future *dead_future EINA_UNUSED)
{ {
Efl_Loop *loop = data;
printf(" Test 3 finished\n"); printf(" Test 3 finished\n");
_test4_chained_future(); _test4_chained_future(loop);
} }
/* TEST 3: Set up a promised future and then cancel it */ /* TEST 3: Set up a promised future and then cancel it */
static void static void
_test3_cancelled_future() _test3_cancelled_future(Efl_Loop *loop)
{ {
Efl_Loop *loop;
Eina_Promise *promise; Eina_Promise *promise;
Eina_Future *future; Eina_Future *future;
// Create a promise // Create a promise
loop = efl_loop_main_get(EFL_LOOP_CLASS);
promise = eina_promise_new(efl_loop_future_scheduler_get(loop), promise = eina_promise_new(efl_loop_future_scheduler_get(loop),
_promise_cancel, NULL); _promise_cancel, NULL);
future = eina_future_new(promise); future = eina_future_new(promise);
@ -192,7 +190,7 @@ _test3_cancelled_future()
.success = _value_print, .success = _value_print,
.error = _error_print, .error = _error_print,
.free = _test3_next_test, .free = _test3_next_test,
.data = promise); .data = loop);
// Cancel the future before it has a chance to resolve // Cancel the future before it has a chance to resolve
eina_future_cancel(future); eina_future_cancel(future);
@ -251,13 +249,11 @@ _exit_cb(void *data EINA_UNUSED, const Eina_Value value EINA_UNUSED,
* it on. * it on.
*/ */
static void static void
_test4_chained_future(void) _test4_chained_future(Efl_Loop *loop)
{ {
Efl_Loop *loop;
Eina_Promise *promise; Eina_Promise *promise;
// Create a promise // Create a promise
loop = efl_loop_main_get(EFL_LOOP_CLASS);
promise = eina_promise_new(efl_loop_future_scheduler_get(loop), promise = eina_promise_new(efl_loop_future_scheduler_get(loop),
_promise_cancel, NULL); _promise_cancel, NULL);
@ -289,10 +285,12 @@ _test4_chained_future(void)
/* ----------------------- Main ---------------------- */ /* ----------------------- Main ---------------------- */
EAPI_MAIN void EAPI_MAIN void
efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED) efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
{ {
Efl_Loop *loop = ev->object;
// Start the first test, the others will be launched when this one finishes // Start the first test, the others will be launched when this one finishes
_test1_simple_future(); _test1_simple_future(loop);
} }
EFL_MAIN() EFL_MAIN()

6
reference/c/net/src/net_session.c
View File

@ -104,11 +104,13 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
Eina_Bool require_online = EINA_FALSE; Eina_Bool require_online = EINA_FALSE;
Efl_Net_Session_Technology technologies; Efl_Net_Session_Technology technologies;
Efl_Net_Session *session; Efl_Net_Session *session;
Efl_Loop *loop;
loop = ev->object;
// create a session that watches specifically for ethernet, wifi and bluetooth // create a session that watches specifically for ethernet, wifi and bluetooth
technologies = EFL_NET_SESSION_TECHNOLOGY_ETHERNET | technologies = EFL_NET_SESSION_TECHNOLOGY_ETHERNET |
EFL_NET_SESSION_TECHNOLOGY_WIFI | EFL_NET_SESSION_TECHNOLOGY_BLUETOOTH; EFL_NET_SESSION_TECHNOLOGY_WIFI | EFL_NET_SESSION_TECHNOLOGY_BLUETOOTH;
session = efl_add(EFL_NET_SESSION_CLASS, efl_loop_main_get(EFL_LOOP_CLASS), session = efl_add(EFL_NET_SESSION_CLASS, loop,
efl_name_set(efl_added, "Example Session"), efl_name_set(efl_added, "Example Session"),
// register the change callback for network state // register the change callback for network state
efl_event_callback_add(efl_added, EFL_NET_SESSION_EVENT_CHANGED, efl_event_callback_add(efl_added, EFL_NET_SESSION_EVENT_CHANGED,
@ -130,7 +132,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
printf("Use ^C (Control + C) to close it\n"); printf("Use ^C (Control + C) to close it\n");
// Wait for 10 seconds before exiting this example // Wait for 10 seconds before exiting this example
efl_add(EFL_LOOP_TIMER_CLASS, ev->object, efl_add(EFL_LOOP_TIMER_CLASS, loop,
efl_loop_timer_interval_set(efl_added, 10.0), efl_loop_timer_interval_set(efl_added, 10.0),
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK,
_quit_cb, NULL)); _quit_cb, NULL));