efl-net: namespace events to avoid naming conflicts

Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Differential Revision: https://phab.enlightenment.org/D8260

36 files changed, 94 insertions, 94 deletions

diff --git a/src/bin/eeze/eeze_scanner/eeze_scanner.c b/src/bin/eeze/eeze_scanner/eeze_scanner.c
index c4d23ea34f..9236b6ab3b 100644
--- a/src/bin/eeze/eeze_scanner/eeze_scanner.c
+++ b/src/bin/eeze/eeze_scanner/eeze_scanner.c
@@ -513,7 +513,7 @@ main(void)
      }
 
    efl_event_callback_add(server, EFL_NET_SERVER_EVENT_CLIENT_ADD, cl_add, NULL);
-   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_ERROR, server_error, NULL);
+   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_SERVER_ERROR, server_error, NULL);
 
 #ifdef EFL_NET_SERVER_UNIX_CLASS
    {
diff --git a/src/bin/efl/efl_debugd.c b/src/bin/efl/efl_debugd.c
index fd2bc9e426..7baffd464d 100644
--- a/src/bin/efl/efl_debugd.c
+++ b/src/bin/efl/efl_debugd.c
@@ -570,7 +570,7 @@ _local_server_create(void)
      }
 
    efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
-   efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
+   efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
 
 #ifdef EFL_NET_SERVER_UNIX_CLASS
    {
@@ -620,7 +620,7 @@ _remote_server_create(void)
       efl_net_server_fd_reuse_address_set(inner_server, EINA_TRUE);
    }
    efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
-   efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
+   efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
 
    sprintf(address, "127.0.0.1:%d", REMOTE_SERVER_PORT);
    err = efl_net_server_serve(_remote_server, address);
diff --git a/src/examples/ecore/efl_io_buffered_stream_example.c b/src/examples/ecore/efl_io_buffered_stream_example.c
index c7fe102890..1f816c7072 100644
--- a/src/examples/ecore/efl_io_buffered_stream_example.c
+++ b/src/examples/ecore/efl_io_buffered_stream_example.c
@@ -236,7 +236,7 @@ efl_main(void *data EINA_UNUSED,
    /* The TCP client to use to send/receive network data */
    dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, ev->object,
                     efl_name_set(efl_added, "dialer"),
-                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
+                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
    if (!dialer)
      {
         fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");
diff --git a/src/examples/ecore/efl_io_copier_example.c b/src/examples/ecore/efl_io_copier_example.c
index 13f26b8577..d4e36b7070 100644
--- a/src/examples/ecore/efl_io_copier_example.c
+++ b/src/examples/ecore/efl_io_copier_example.c
@@ -77,9 +77,9 @@ _dialer_connected(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _dialer_resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _dialer_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _dialer_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected });
 
 static void
 _http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)
diff --git a/src/examples/ecore/efl_io_queue_example.c b/src/examples/ecore/efl_io_queue_example.c
index 62e6035450..7a22feb631 100644
--- a/src/examples/ecore/efl_io_queue_example.c
+++ b/src/examples/ecore/efl_io_queue_example.c
@@ -305,7 +305,7 @@ efl_main(void *data EINA_UNUSED,
    /* The TCP client to use to send/receive network data */
    dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, loop,
                     efl_name_set(efl_added, "dialer"),
-                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
+                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
    if (!dialer)
      {
         fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");
diff --git a/src/examples/ecore/efl_net_dialer_http_example.c b/src/examples/ecore/efl_net_dialer_http_example.c
index 02783dc165..1289fb01ba 100644
--- a/src/examples/ecore/efl_net_dialer_http_example.c
+++ b/src/examples/ecore/efl_net_dialer_http_example.c
@@ -71,9 +71,9 @@ _http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _http_headers_done },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos });
 
diff --git a/src/examples/ecore/efl_net_dialer_simple_example.c b/src/examples/ecore/efl_net_dialer_simple_example.c
index 1285dae2f1..40243cc11f 100644
--- a/src/examples/ecore/efl_net_dialer_simple_example.c
+++ b/src/examples/ecore/efl_net_dialer_simple_example.c
@@ -176,8 +176,8 @@ _done(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected }, /* optional */
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved }, /* optional */
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected }, /* optional */
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved }, /* optional */
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read }, /* optional, can be used to read data, here just for monitoring */
                            { EFL_IO_READER_EVENT_EOS, _eos }, /* recommended, notifies no more incoming data */
                            { EFL_IO_BUFFERED_STREAM_EVENT_LINE, _line }, /* optional, could use 'slice,changed' or 'can_read,changed' instead */
diff --git a/src/examples/ecore/efl_net_dialer_udp_example.c b/src/examples/ecore/efl_net_dialer_udp_example.c
index bb01b58f8a..3fef035eef 100644
--- a/src/examples/ecore/efl_net_dialer_udp_example.c
+++ b/src/examples/ecore/efl_net_dialer_udp_example.c
@@ -156,9 +156,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }
                            );
diff --git a/src/examples/ecore/efl_net_dialer_unix_example.c b/src/examples/ecore/efl_net_dialer_unix_example.c
index f0298aed4a..8cfb2213e1 100644
--- a/src/examples/ecore/efl_net_dialer_unix_example.c
+++ b/src/examples/ecore/efl_net_dialer_unix_example.c
@@ -108,9 +108,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }
diff --git a/src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c b/src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c
index 037a0aca52..45a3ed2ae4 100644
--- a/src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c
+++ b/src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c
@@ -247,8 +247,8 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_EVENT_DEL, _del });
diff --git a/src/examples/ecore/efl_net_dialer_websocket_example.c b/src/examples/ecore/efl_net_dialer_websocket_example.c
index e46a8c78a9..a74323b3db 100644
--- a/src/examples/ecore/efl_net_dialer_websocket_example.c
+++ b/src/examples/ecore/efl_net_dialer_websocket_example.c
@@ -145,9 +145,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos });
 
diff --git a/src/examples/ecore/efl_net_dialer_windows_example.c b/src/examples/ecore/efl_net_dialer_windows_example.c
index 44daab0bfa..e5be598eac 100644
--- a/src/examples/ecore/efl_net_dialer_windows_example.c
+++ b/src/examples/ecore/efl_net_dialer_windows_example.c
@@ -106,9 +106,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }
diff --git a/src/examples/ecore/efl_net_server_example.c b/src/examples/ecore/efl_net_server_example.c
index b599336960..4c3f200339 100644
--- a/src/examples/ecore/efl_net_server_example.c
+++ b/src/examples/ecore/efl_net_server_example.c
@@ -450,7 +450,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char * protocols[] = {
diff --git a/src/examples/ecore/efl_net_server_simple_example.c b/src/examples/ecore/efl_net_server_simple_example.c
index 6477ad2a3d..36a2d8c06d 100644
--- a/src/examples/ecore/efl_net_server_simple_example.c
+++ b/src/examples/ecore/efl_net_server_simple_example.c
@@ -254,7 +254,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char * protocols[] = {
diff --git a/src/examples/ecore/efl_net_socket_ssl_dialer_example.c b/src/examples/ecore/efl_net_socket_ssl_dialer_example.c
index 0bc77c3477..1ade6bc9c2 100644
--- a/src/examples/ecore/efl_net_socket_ssl_dialer_example.c
+++ b/src/examples/ecore/efl_net_socket_ssl_dialer_example.c
@@ -177,9 +177,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error });
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error });
 
 
 static char *
diff --git a/src/examples/ecore/efl_net_socket_ssl_server_example.c b/src/examples/ecore/efl_net_socket_ssl_server_example.c
index 33b67d2b21..6d826b6047 100644
--- a/src/examples/ecore/efl_net_socket_ssl_server_example.c
+++ b/src/examples/ecore/efl_net_socket_ssl_server_example.c
@@ -153,7 +153,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char *ciphers_strs[] = {
diff --git a/src/lib/ecore_con/ecore_con_legacy.c b/src/lib/ecore_con/ecore_con_legacy.c
index 0e241b7fa9..5cbb39bf65 100644
--- a/src/lib/ecore_con/ecore_con_legacy.c
+++ b/src/lib/ecore_con/ecore_con_legacy.c
@@ -1420,9 +1420,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_dialer_cbs,
                            { EFL_IO_BUFFERED_STREAM_EVENT_READ_FINISHED, _ecore_con_server_dialer_read_finished },
                            { EFL_IO_BUFFERED_STREAM_EVENT_FINISHED, _ecore_con_server_dialer_finished },
                            { EFL_IO_BUFFERED_STREAM_EVENT_ERROR, _ecore_con_server_dialer_error },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_con_server_dialer_error },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _ecore_con_server_dialer_resolved },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _ecore_con_server_dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_server_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _ecore_con_server_dialer_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_con_server_dialer_connected });
 
 static void
 _ecore_con_server_server_client_add(void *data, const Efl_Event *event)
@@ -1495,7 +1495,7 @@ _ecore_con_server_server_error(void *data, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _ecore_con_server_server_client_add },
                            { EFL_NET_SERVER_EVENT_SERVING, _ecore_con_server_server_serving },
-                           { EFL_NET_SERVER_EVENT_ERROR, _ecore_con_server_server_error });
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _ecore_con_server_server_error });
 
 /**
  * @addtogroup Ecore_Con_Server_Group Ecore Connection Server Functions
diff --git a/src/lib/ecore_con/ecore_con_url.c b/src/lib/ecore_con/ecore_con_url.c
index b78498aa0e..27b391c32d 100644
--- a/src/lib/ecore_con/ecore_con_url.c
+++ b/src/lib/ecore_con/ecore_con_url.c
@@ -508,7 +508,7 @@ _ecore_con_url_dialer_headers_done(void *data, const Efl_Event *event EINA_UNUSE
 EFL_CALLBACKS_ARRAY_DEFINE(ecore_con_url_dialer_cbs,
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _ecore_con_url_dialer_can_read_changed },
                            { EFL_IO_READER_EVENT_EOS, _ecore_con_url_dialer_eos },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_con_url_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_url_dialer_error },
                            { EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _ecore_con_url_dialer_headers_done });
 
 static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_dialer.eo b/src/lib/ecore_con/efl_net_dialer.eo
index 7abba99b1a..fb79de10ce 100644
--- a/src/lib/ecore_con/efl_net_dialer.eo
+++ b/src/lib/ecore_con/efl_net_dialer.eo
@@ -112,7 +112,7 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
 
     events {
         /* FIXME: Might be NULL, but @nullable does not work on event types */
-        resolved: string; [[Notifies @.address_dial was resolved to
+        dialer,resolved: string; [[Notifies @.address_dial was resolved to
                             @Efl.Net.Socket.address_remote.
 
                             This is emitted before "connected" and may
@@ -124,9 +124,9 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
                             may be emitted multiple times, such as
                             HTTP.
                           ]]
-        error: Eina.Error; [[Some error happened and the socket
+        dialer,error: Eina.Error; [[Some error happened and the socket
                              stopped working.
                            ]]
-        connected: void; [[Notifies the socket is connected to the remote peer.]]
+        dialer,connected: void; [[Notifies the socket is connected to the remote peer.]]
     }
 }
diff --git a/src/lib/ecore_con/efl_net_dialer_http.c b/src/lib/ecore_con/efl_net_dialer_http.c
index aa7698afa6..64947a1fc4 100644
--- a/src/lib/ecore_con/efl_net_dialer_http.c
+++ b/src/lib/ecore_con/efl_net_dialer_http.c
@@ -318,7 +318,7 @@ _efl_net_dialer_http_curlm_check(Efl_Net_Dialer_Http_Curlm *cm)
         efl_ref(dialer);
         pd = efl_data_scope_get(dialer, MY_CLASS);
         if (pd->error)
-          efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_ERROR, &pd->error);
+          efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_DIALER_ERROR, &pd->error);
         if (pd->recv.used > 0) pd->pending_eos = EINA_TRUE;
         else
           {
@@ -1460,7 +1460,7 @@ _efl_net_dialer_http_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Http_Dat
     * allow_redirects will trigger more than once
     */
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
@@ -1524,7 +1524,7 @@ EOLIAN static void
 _efl_net_dialer_http_efl_net_socket_address_remote_set(Eo *o, Efl_Net_Dialer_Http_Data *pd, const char *address)
 {
    if (eina_stringshare_replace(&pd->address_remote, address))
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 EOLIAN static const char *
diff --git a/src/lib/ecore_con/efl_net_dialer_simple.c b/src/lib/ecore_con/efl_net_dialer_simple.c
index 71e99e8736..775621a97a 100644
--- a/src/lib/ecore_con/efl_net_dialer_simple.c
+++ b/src/lib/ecore_con/efl_net_dialer_simple.c
@@ -33,14 +33,14 @@ static void
 _efl_net_dialer_simple_inner_io_resolved(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, event->info);
 }
 
 static void
 _efl_net_dialer_simple_inner_io_error(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, event->info);
 }
 
 static void
@@ -48,13 +48,13 @@ _efl_net_dialer_simple_inner_io_connected(void *data, const Efl_Event *event)
 {
    Eo *o = data;
 
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, event->info);
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_simple_inner_io_cbs,
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_simple_inner_io_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_simple_inner_io_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
 
 EOLIAN static Efl_Object *
 _efl_net_dialer_simple_efl_object_finalize(Eo *o, Efl_Net_Dialer_Simple_Data *pd)
diff --git a/src/lib/ecore_con/efl_net_dialer_ssl.c b/src/lib/ecore_con/efl_net_dialer_ssl.c
index 33d314f2f4..ffc36a6f58 100644
--- a/src/lib/ecore_con/efl_net_dialer_ssl.c
+++ b/src/lib/ecore_con/efl_net_dialer_ssl.c
@@ -50,7 +50,7 @@ _efl_net_dialer_ssl_error(void *data EINA_UNUSED, const Efl_Event *event)
 {
    Eo *o = event->object;
    Eina_Error *perr = event->info;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_ssl_cbs,
@@ -134,7 +134,7 @@ _efl_net_dialer_ssl_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -205,7 +205,7 @@ _efl_net_dialer_ssl_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Ssl_Data
      eina_future_cancel(pd->connect_timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_dialer_tcp.c b/src/lib/ecore_con/efl_net_dialer_tcp.c
index 9a7a795faa..ba93fc4c74 100644
--- a/src/lib/ecore_con/efl_net_dialer_tcp.c
+++ b/src/lib/ecore_con/efl_net_dialer_tcp.c
@@ -99,7 +99,7 @@ _efl_net_dialer_tcp_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -128,7 +128,7 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
    efl_loop_fd_set(o, sockfd);
    if (efl_net_socket_address_remote_get(o))
      {
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_net_dialer_connected_set(o, EINA_TRUE);
      }
    else
@@ -148,11 +148,11 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
              if (efl_net_ip_port_fmt(buf, sizeof(buf), addr))
                {
                   efl_net_socket_address_remote_set(o, buf);
-                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
                }
           }
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 
    efl_unref(o);
@@ -245,7 +245,7 @@ _efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data
    if (!connected) _efl_net_dialer_tcp_async_stop(pd);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_dialer_udp.c b/src/lib/ecore_con/efl_net_dialer_udp.c
index b42e9d414e..e75ed24fed 100644
--- a/src/lib/ecore_con/efl_net_dialer_udp.c
+++ b/src/lib/ecore_con/efl_net_dialer_udp.c
@@ -95,7 +95,7 @@ _efl_net_dialer_udp_resolver_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -184,7 +184,7 @@ _efl_net_dialer_udp_resolved_bind(Eo *o, Efl_Net_Dialer_Udp_Data *pd EINA_UNUSED
    if (remote_address)
      {
         efl_net_socket_udp_init(o, remote_address);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_del(remote_address);
      }
    efl_net_dialer_connected_set(o, EINA_TRUE);
@@ -230,12 +230,12 @@ _efl_net_dialer_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
              if (efl_net_ip_port_fmt(buf, sizeof(buf), result->ai_addr))
                {
                   efl_net_socket_address_remote_set(o, buf);
-                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
                }
           }
 
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
    freeaddrinfo(result);
 
@@ -319,7 +319,7 @@ _efl_net_dialer_udp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Udp_Data
    if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_dialer_unix.c b/src/lib/ecore_con/efl_net_dialer_unix.c
index 95e2b06457..b2d3dfce39 100644
--- a/src/lib/ecore_con/efl_net_dialer_unix.c
+++ b/src/lib/ecore_con/efl_net_dialer_unix.c
@@ -84,7 +84,7 @@ _efl_net_dialer_unix_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -105,7 +105,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
    efl_loop_fd_set(o, sockfd);
    if (efl_net_socket_address_remote_get(o))
      {
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_net_dialer_connected_set(o, EINA_TRUE);
      }
    else
@@ -120,7 +120,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
    if (err)
      {
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 
    efl_unref(o);
@@ -222,7 +222,7 @@ _efl_net_dialer_unix_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Unix_Dat
    if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_dialer_websocket.c b/src/lib/ecore_con/efl_net_dialer_websocket.c
index 8d8719ad04..78ab750756 100644
--- a/src/lib/ecore_con/efl_net_dialer_websocket.c
+++ b/src/lib/ecore_con/efl_net_dialer_websocket.c
@@ -350,7 +350,7 @@ _efl_net_dialer_websocket_job_send(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
    if ((err) && (err != EAGAIN))
      {
         ERR("could not write to HTTP socket #%d '%s'", err, eina_error_msg_get(err));
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 }
 
@@ -730,7 +730,7 @@ _efl_net_dialer_websocket_job_receive(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
        eina_error_msg_get(err));
    efl_ref(o);
    efl_io_closer_close(pd->http);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
 }
 
@@ -819,7 +819,7 @@ _efl_net_dialer_websocket_http_error(void *data, const Efl_Event *event)
      return;
    efl_ref(o);
    if (!efl_io_closer_closed_get(o)) efl_io_closer_close(o);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
    efl_unref(o);
 }
 
@@ -846,7 +846,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
             status, EFL_NET_HTTP_STATUS_SWITCHING_PROTOCOLS);
         efl_ref(o);
         efl_io_closer_close(pd->http);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
         efl_unref(o);
         return;
      }
@@ -887,7 +887,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
             upgraded, connection_websocket, accepted);
         efl_ref(o);
         efl_io_closer_close(pd->http);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
         efl_unref(o);
         return;
      }
@@ -934,7 +934,7 @@ EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_websocket_http_cbs,
                            {EFL_IO_READER_EVENT_CAN_READ_CHANGED, _efl_net_dialer_websocket_http_can_read_changed},
                            {EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _efl_net_dialer_websocket_http_can_write_changed},
                            {EFL_IO_CLOSER_EVENT_CLOSED, _efl_net_dialer_websocket_http_closed},
-                           {EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_websocket_http_error},
+                           {EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_websocket_http_error},
                            {EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _efl_net_dialer_websocket_http_headers_done});
 
 EOLIAN static Efl_Object *
@@ -1182,7 +1182,7 @@ _efl_net_dialer_websocket_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Web
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected)
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
@@ -1225,7 +1225,7 @@ EOLIAN static void
 _efl_net_dialer_websocket_efl_net_socket_address_remote_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Websocket_Data *pd, const char *address)
 {
    if (eina_stringshare_replace(&pd->address_remote, address))
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 EOLIAN static const char *
diff --git a/src/lib/ecore_con/efl_net_dialer_windows.c b/src/lib/ecore_con/efl_net_dialer_windows.c
index 8e78446b6f..bf6d525e36 100644
--- a/src/lib/ecore_con/efl_net_dialer_windows.c
+++ b/src/lib/ecore_con/efl_net_dialer_windows.c
@@ -100,7 +100,7 @@ _efl_net_dialer_windows_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Windows_Data *
 
    efl_net_socket_address_remote_set(o, sstr);
    efl_net_socket_address_local_set(o, cstr);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
    efl_net_dialer_connected_set(o, EINA_TRUE);
 
    return _efl_net_socket_windows_io_start(o);
@@ -125,7 +125,7 @@ _efl_net_dialer_windows_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Windo
 {
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/ecore_con/efl_net_server.eo b/src/lib/ecore_con/efl_net_server.eo
index 141cf9d0ae..0f23e5af54 100644
--- a/src/lib/ecore_con/efl_net_server.eo
+++ b/src/lib/ecore_con/efl_net_server.eo
@@ -26,7 +26,7 @@ interface @beta Efl.Net.Server {
                                    excess, see @.clients_limit.
                                  ]]
 
-        error: Eina.Error; [[An error has occurred and the server needs
+        server,error: Eina.Error; [[An error has occurred and the server needs
                              to be stopped.
                            ]]
         serving: void; [[Notifies the server is ready to accept clients.
diff --git a/src/lib/ecore_con/efl_net_server_fd.c b/src/lib/ecore_con/efl_net_server_fd.c
index 28626b0712..e4e6461576 100644
--- a/src/lib/ecore_con/efl_net_server_fd.c
+++ b/src/lib/ecore_con/efl_net_server_fd.c
@@ -81,7 +81,7 @@ _efl_net_server_fd_event_error(void *data EINA_UNUSED, const Efl_Event *event)
    Eina_Error err = EBADF;
 
    efl_net_server_serving_set(o, EINA_FALSE);
-   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 }
 
 EOLIAN static Efl_Object *
@@ -474,7 +474,7 @@ _efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Server_Fd_Data *pd)
      {
         Eina_Error err = efl_net_socket_error_get();
         ERR("accept(" SOCKET_FMT "): %s", fd, eina_error_msg_get(err));
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         return;
      }
 
diff --git a/src/lib/ecore_con/efl_net_server_simple.c b/src/lib/ecore_con/efl_net_server_simple.c
index 8c0c4a6732..46924fae25 100644
--- a/src/lib/ecore_con/efl_net_server_simple.c
+++ b/src/lib/ecore_con/efl_net_server_simple.c
@@ -109,7 +109,7 @@ static void
 _efl_net_server_simple_inner_server_error(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, event->info);
+   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, event->info);
 }
 
 static void
@@ -122,7 +122,7 @@ _efl_net_server_simple_inner_server_serving(void *data, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_server_simple_inner_server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _efl_net_server_simple_inner_server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _efl_net_server_simple_inner_server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _efl_net_server_simple_inner_server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _efl_net_server_simple_inner_server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _efl_net_server_simple_inner_server_serving });
 
 EOLIAN static Efl_Object *
diff --git a/src/lib/ecore_con/efl_net_server_tcp.c b/src/lib/ecore_con/efl_net_server_tcp.c
index e4e5bcb377..b4bda04192 100644
--- a/src/lib/ecore_con/efl_net_server_tcp.c
+++ b/src/lib/ecore_con/efl_net_server_tcp.c
@@ -138,7 +138,7 @@ _efl_net_server_tcp_resolved(void *data, const char *host EINA_UNUSED, const cha
    freeaddrinfo(result);
 
  end:
-   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    efl_unref(o);
 }
diff --git a/src/lib/ecore_con/efl_net_server_udp.c b/src/lib/ecore_con/efl_net_server_udp.c
index 50a0c97908..0f0b2287e9 100644
--- a/src/lib/ecore_con/efl_net_server_udp.c
+++ b/src/lib/ecore_con/efl_net_server_udp.c
@@ -142,7 +142,7 @@ _efl_net_server_udp_resolved_bind(Eo *o, Efl_Net_Server_Udp_Data *pd, const stru
         if (mr)
           {
              ERR("could not join pending multicast group '%s': %s", mcast_addr, eina_error_msg_get(mr));
-             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &mr);
+             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &mr);
           }
      }
 
@@ -191,7 +191,7 @@ _efl_net_server_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
    freeaddrinfo(result);
 
  end:
-   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    efl_unref(o);
 }
@@ -328,7 +328,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
         Eina_Error err = efl_net_socket_error_get();
         ERR("recvfrom(" SOCKET_FMT ", %p, %zu, 0, %p, %d): %s", fd, buf, buflen, &addr, addrlen, eina_error_msg_get(err));
         free(buf);
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         return;
      }
    if ((size_t)r < buflen)
@@ -341,7 +341,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
 
              free(buf);
              ERR("Out of memory on efl net udp data incoming");
-             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
              return;
           }
      }
diff --git a/src/lib/ecore_con/efl_net_server_unix.c b/src/lib/ecore_con/efl_net_server_unix.c
index 38280c27c8..ed8735fb0b 100644
--- a/src/lib/ecore_con/efl_net_server_unix.c
+++ b/src/lib/ecore_con/efl_net_server_unix.c
@@ -165,7 +165,7 @@ _efl_net_server_unix_bind(Eo *o, Efl_Net_Server_Unix_Data *pd)
  error:
    if (err)
      {
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         if (fd != INVALID_SOCKET) closesocket(fd);
         efl_loop_fd_set(o, SOCKET_TO_LOOP_FD(INVALID_SOCKET));
      }
diff --git a/src/lib/ecore_con/efl_net_server_windows.c b/src/lib/ecore_con/efl_net_server_windows.c
index 68e7fe9906..454e87c547 100644
--- a/src/lib/ecore_con/efl_net_server_windows.c
+++ b/src/lib/ecore_con/efl_net_server_windows.c
@@ -151,7 +151,7 @@ _efl_net_server_windows_client_listen_failure(void *data, Eo *client EINA_UNUSED
      }
 
    if (err)
-     efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+     efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    // TODO: create a new one on failure?
 
diff --git a/src/lib/ecore_con/efl_net_socket_ssl.c b/src/lib/ecore_con/efl_net_socket_ssl.c
index 912a8cbb87..4d2c0c08f4 100644
--- a/src/lib/ecore_con/efl_net_socket_ssl.c
+++ b/src/lib/ecore_con/efl_net_socket_ssl.c
@@ -225,7 +225,7 @@ efl_net_socket_ssl_sock_resolved(void *data, const Efl_Event *event EINA_UNUSED)
 
    if (pd->torndown) return;
 
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 static void
@@ -250,8 +250,8 @@ efl_net_socket_ssl_sock_connected(void *data, const Efl_Event *event EINA_UNUSED
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(efl_net_socket_ssl_sock_dialer_cbs,
-                           {EFL_NET_DIALER_EVENT_RESOLVED, efl_net_socket_ssl_sock_resolved},
-                           {EFL_NET_DIALER_EVENT_CONNECTED, efl_net_socket_ssl_sock_connected});
+                           {EFL_NET_DIALER_EVENT_DIALER_RESOLVED, efl_net_socket_ssl_sock_resolved},
+                           {EFL_NET_DIALER_EVENT_DIALER_CONNECTED, efl_net_socket_ssl_sock_connected});
 
 static void
 _efl_net_socket_ssl_context_del(void *data, const Efl_Event *event EINA_UNUSED)
diff --git a/src/lib/ecore_ipc/ecore_ipc.c b/src/lib/ecore_ipc/ecore_ipc.c
index 094e95aed1..97b263784b 100644
--- a/src/lib/ecore_ipc/ecore_ipc.c
+++ b/src/lib/ecore_ipc/ecore_ipc.c
@@ -607,8 +607,8 @@ _ecore_ipc_dialer_connected(void *data, const Efl_Event *event EINA_UNUSED)
 
 EFL_CALLBACKS_ARRAY_DEFINE(_ecore_ipc_dialer_cbs,
                            { EFL_IO_READER_EVENT_EOS, _ecore_ipc_dialer_eos },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_ipc_dialer_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _ecore_ipc_dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_ipc_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_ipc_dialer_connected });
 
 static Eina_Bool ecore_ipc_server_data_process(Ecore_Ipc_Server *svr, void *data, int size, Eina_Bool *stolen);