This example shows how to setup, and explains how an Ecore_Poller is called. You can see the full source code here.

In this example we store the initial time of the program just to use as comparison to the time when the poller callbacks are called. It will be stored in _initial_time :

//Compile with:
// gcc -o ecore_poller_example ecore_poller_example.c `pkg-config --libs --cflags ecore eo`

#include <Ecore.h>
//#include <Ecore_Eo.h>
#include <unistd.h>

static double _initial_time = 0;

Then next step is to define the poller callback. This callback assumes that a data pointer is passed to it on creation, and is a string just used to identify the poller. The callback prints this string and the time since the program started, and returns ECORE_CALLBACK_RENEW to keep being called.

static Eina_Bool
_poller_print_cb(void *data)
{
   char *str = data;
   printf("Ecore Poller '%s' callback called after %0.3f seconds.\n",
          str, ecore_time_get() - _initial_time);

   return ECORE_CALLBACK_RENEW;
}

Now in the main function we initialize Ecore, and save the initial time of the program, so we can compare it later with the time that the pollers are being called:

static Eina_Bool
_poller_quit_cb(void *data EINA_UNUSED)
{

   ecore_main_loop_quit();
   return EINA_TRUE;
}

int
main(void)
{
   double interval = 0.3; // tick each 0.3 seconds
   Ecore_Poller *poller1, *poller2, *poller3;
   char *str1 = "poller1";
   char *str2 = "poller2";
   char *str3 = "poller3";

   if (!ecore_init())
     {
        printf("ERROR: Cannot init Ecore!\n");
        return -1;
     }

   _initial_time = ecore_time_get();

Then we change the poll interval to 0.3 seconds (the default is 0.125 seconds) just to show the API usage.

Finally, we create two pollers, one that will be called every 4 ticks, and another one that will be called every 8 ticks. This means the the first poller interval will be around 1.2 seconds, and the second one will be around 2.4 seconds. But the most important point is: since the second poller interval is a multiple of the first one, they will be always synchronized. Ecore calls pollers that are in the "same tick" together. It doesn't go back to the main loop and check if there's another poller to execute at this time, but instead it calls all the pollers registered to this "tick" at the same time. See the description of ecore_poller_add() for more details. This is easy to see in the time printed by both of them.

If instead of two synchronized pollers, we were using two different timers, one with interval of 1.2 seconds and another one with an interval of 2.4 seconds, there would be no guarantee that they would be totally in sync. Some delay in the execution of another task, or even in the task called in the callback, could make them get out of sync, forcing Ecore's main loop to wake up more than necessary.

Well, this is the code that create these two pollers and set the poll interval, then starts the main loop:

   ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval);

   poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1);
   poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2);
   poller3 = ecore_poller_add(ECORE_POLLER_CORE, 30, _poller_quit_cb, str3);

//   poller1 = efl_add_ref(ECORE_POLLER_CLASS, NULL, //         ecore_poller_constructor(efl_added, ECORE_POLLER_CORE, 4, _poller_print_cb, str1));
//   poller2 = efl_add_ref(ECORE_POLLER_CLASS, NULL, //         ecore_poller_constructor(efl_added, ECORE_POLLER_CORE, 8, _poller_print_cb, str2));
//   poller3 = efl_add_ref(ECORE_POLLER_CLASS, NULL, //         ecore_poller_constructor(efl_added, ECORE_POLLER_CORE, 20, _poller_quit_cb, str3));


   ecore_main_loop_begin();

If you hit CTRL-C during the execution of the program, the main loop will quit, since there are some signal handlers already set by default to do this. So after the main loop begin call, we change the second poller's interval to 16 ticks, so it will happen each 4.8 seconds (or each 4 times that the first poller is called).

This means: the program is started, the first poller is called each 4 ticks and the second is called each 8 ticks. After CTRL-C is used, the second poller will be called each 16 ticks.

   printf("changing poller2 interval to 16\n");

   ecore_poller_poller_interval_set(poller2, 16);
//   ecore_poller_interval_set(poller2, 16, NULL);
   ecore_main_loop_begin();

//   efl_unref(poller1);
//   efl_unref(poller2);
//   efl_unref(poller3);
   ecore_poller_del(poller1);
   ecore_poller_del(poller2);
   ecore_poller_del(poller3);

   ecore_shutdown();
}

The rest of the program is just deleting the pollers and shutting down the library.