During shutdown it is possible that some event are still in ecore events
queue and get processed after the shutdown of the module that did emit them.
This would lead to crash in some case. The answer to this problem is to
normally manually track all ecore event in the queue and destroy them
before shutdown... Of course that make the API difficult to use and
basically nobody got it right.
This new API do actually as it says remove all the ecore event of a
certain type from ecore events queue. It is to be called on shutdown.
@fix
We need to make sure that we wait properly on the animator thread
otherwise we end up with the animator finish callback being called
later on during the shutdown process which means trouble.
This reverts commit 2c6808e4ee.
this breaks a number of expectations and guarantees in efl:
* causes unexpected event iteration during app startup before main loop begins
- leads to event loss
* causes unexpected event iteration during app shutdown after main loop quits
- leads to invalid memory access
* causes recursive event iteration during event handler callbacks
- leads to ?????????????????????????????????????????????????????????????????
all of these can be easily seen by running enlightenment, and all of these cause
unexpected behaviors in enlightenment including, but not limited to, a lot of crashes
fix T5232
Small patch to change the name of the ecore_animator logging domain.
Names with spaces in them make it impossible to export
EINA_LOG_LEVELS_GLOB inside a bashrc
Signed-off-by: Chris Michael <cp.michael@samsung.com>
If a component emit Ecore_Event and they aren't processed before the
call it call ecore_shutdown, there is no way to prevent this event
from being triggered after the component at shutdown itself. Which
may well lead to a use after free case. As we don't know which event
are pending and we also are not shuting down ecore completely as they
are still other component using it, we can only flush all pending event
right away.
Summary: There are some typos and calogique statements in doxygen
of Ecore_Getopt and Ecore_Legacy so I had fixed typos and cacologique statements.
Test Plan: Doxygen revision
Reviewers: stefan, cedric, raster, Jaehyun_Cho
Subscribers: jpeg, conr2d
Differential Revision: https://phab.enlightenment.org/D4651
Not sure _ecore_fd_valid() is all that useful anymore, as the
commit that introduced it said it would be removed "before release"
a long time ago - it's a debug assist that probably doesn't need
to be in release builds.
(I'm counting syscalls on rpi3 - still, calling this an optimization
seems like a bit of a stretch.)
Summary: There are some typos and calogique statements in doxygen of Ecore_Common so I had fixed typos, cacologique statements.
Test Plan: doxygen revision
Reviewers: stefan, cedric, raster, Jaehyun_Cho
Subscribers: conr2d, jpeg
Differential Revision: https://phab.enlightenment.org/D4650
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Add Efl.Model.Composite.Boolean, a model for wrapping another Efl.Model and
adding boolean properties to its children.
Children of the given composite model will have the boolean properties
specified in Efl.Model.Composite.Boolean with the specified default value.
A call to Efl.Model.Property_set can change the property value for a child.
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Efl.Model.Container and Efl.Model.Item to efl/interfaces are used
to create Efl.Model objects with predefined property values.
This is useful to any situation where we want an Efl.Model with
explicit defined property values.
Efl.Ui.View and Efl.Ui.Factory are used to connect Efl.Models with
Widgets, Elm.Layout and Efl.Ui.Image has changed to use news interfaces
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Waiting would sometimes return as if the thread finished correctly while it is still running.
This is because we’re waiting for the waiter data to be null… but this is always the case if the user-passed data is null!
@fix
This is particularly useful for ecore_timer_loop_add which are not
supposed to trigger any syscall. It does add a new requirement
on the EFL_LOOP_TIME_CLASS to always have an interval defined during
construction.
Built on top of the new 'postponed' free queue, the short-lived
strings API allows users to return new strings without caring
about freeing them. EFL main loop will do this automatically for
them you at a later point in time (at the end of an iteration).
The APIs provided will either duplicate (copy) or more generally
steal an existing string (char *, stringshare, tmpstr, strbuf),
taking ownership of it and controling its lifetime. Those strings
can then be safely returned by an API. From a user point of view,
those strings must be considered like simple const char *, ie.
no need to free() them and their validity is limited to the
local scope.
There is no function to remove such a string from the freeq.
The short lived strings API is not thread-safe: do not send a
short-lived object from one thread to another.
@feature
Now you can't use the same syntax as you would for a method to
implement a property as whole, instead you need to specify the
getter and/or setter explicitly. This is to allow parent classes
to expand their properties without altering behavior of the child
classes.
it can contain old callback values which are not overwritten in every
case. This just ensures that in both cases, empty trasher or none empty
trasher, are returning the same state of the struct.
Check for bytes written only if more than 0 bytes were sent.
I don't know why some efl code is trying to send 0 bytes, but that works on
Linux and therefore should be fixed on Windows.
Summary:
T4938
diff from @raster
Aaaargh! There is no other way to get code from diff on phab..
Reviewers: vtorri
Subscribers: vtorri, i.furs, cedric, jpeg, raster
Differential Revision: https://phab.enlightenment.org/D4448
By marking EOS on the outgoing queue we allow the sender to flush
pending data if that's possible.
This also fixes a typo in the condition for eos_mark, it operates on
outgoing, not incoming queue.
Before we're exiting if there was nothing pending, but in some cases
this was too aggressive as the copier's source may be alive (ie:
not-EOS), however nothing was read to its internal buffer, thus no
pending.
Since the copier will track its source's EOS, just check if it's done.
On destructor we're not supposed to emit events, I even thought that
would be implicit, but it's not. If we do, for example an event
handler that would 'efl_del()' on "EFL_IO_CLOSER_EVENT_CLOSED" would
trigger too-many unrefs.
Copier is based on Efl.Io.Reader.can_read,changed and
Efl.Io.Writer.can_write,changed, these events do not keep being posted
until it's actually read/written, instead they trigger only once when
the property change -- unlike Efl.Loop_Fd read/write events.
Working directly with Eina_Slice is easier than a pointer to it,
requires no validation of the pointers and is cheap since it's just
putting together size_t + void*.
However we can't hint the user of 'const(Eina.Slice)' properties as
Eolian is incorrectly generating getters as:
const Eina_Slice class_property_get(...)
which is makes compilers complain about ignored qualifiers:
../src/lib/ecore/efl_io_copier.eo.h:329:7: warning: 'const' type qualifier on return type has no effect [-Wignored-qualifiers]
Leave some TODO so @q66 can fix those.
Previously we couldn't return a slice, instead required the user to
pass a slice and we'd fill it since Eolian couldn't generate fallbacks
for structures.
Since @q66 fixed eolian, we can now return the structure itself as
initially wanted, ditching some TODO from the code.
This makes efl_loop_get() work on evas objects, returning the
main loop as expected. Also make the loop a property of the
Loop_User class (shouldn't it be called Efl.Loop.User instead?)
In some cases the copier isn't done but you know there is not more
data to arrive at it, then you want to know if all pending data was
flushed from the copier's intermediate buffer to the destination, if
so you can call it closed yourself.
This reverts commit c505b754ce.
Accidentally pushed this with build fix. Sorry :(
This commit is related to T4938 and it's goint to be updated, checked and pushed later.
Summary:
Currently eolian abbreviates when only the last word of class name and
the first word of method name are same, but this patch abbreviates
generated c name of function to remove all duplicated affix.
For example, "efl_io_closer_fd_closer_fd_set" will be "efl_io_closer_fd_set".
Reviewers: jpeg
Subscribers: cedric
Differential Revision: https://phab.enlightenment.org/D4430
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
the ecore time based animator that ticked away used select for
timeouts to listen to either a timeout OR the control fd that would
tell it to tick or not tick. my profiles show this as consuming 1.03%
of my profile sample time - just the select call in the time based
animator. this adds the option of epoll + timerfd + having kernel
repeat the timer fd interval (since epoll timeouts at best can do 1ms
resolution). my profiling shows this to use 0.62% of profile time vs
1.03% for select, so it's a tiny win. this only compiles if epoll and
timerfd support have already been detected at compile time. it also
runtime falls back to select if epoll and timerfd setup fail.
@optimize
Since all other efl.io objects are low-level, the recommended approach
is to use an efl.io.copier. However when dealing with in-memory,
bi-directional comms like talking to a socket, we always end with 2
queues, 2 copiers and the annoying setup that is being replicated in
ecore_ipc, efl_debug and so on.
This class is the base to make it simpler. Other classes such as
Efl.Net.Socket.Simple, Efl.Net.Dialer.Simple and Efl.Net.Server.Simple
will use it to provide simpler code to users.
I guess we can call EFL+EO Java now?
The may_block parameter is useful to force a flush without blocking on
read/write, sometimes particularly useful if ignore_line_delimiter is
true, then you get the data events without blocking -- as if a server
sending some content misses a trailing line delimiter, you do not want
to block on recv() but still want to flush data to user.
The ignore_line_delimiter parameter is useful if we're going to close
the copier and want to flush pending data which may exist due missing
trailing terminator. The close method will also force that if
destination can take more data.
as soon as we report 'can_read' or 'can_write', stop monitoring the
events until the user executes the operation, which will clear these
flags and we resume monitoring.
instead of always delete and recreate it, modify if it already exists
and only delete if it's not needed anymore.
This results in epoll_ctl() to modify an existing handle, instead of
add one.
This method will force a read-write cycle and returns if it's fully
done or not. It may be used to force data to be written before a
handle is deleted (when one can't wait for the data to be written
asynchronously).