set tdm output list's first element to main

[platform/core/uifw/libtdm.git] / src / tdm_event_loop.c

diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c
index e2beaf7..1cfaad2 100644 (file)
--- a/src/tdm_event_loop.c
+++ b/src/tdm_event_loop.c
@@ -43,14 +43,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <wayland-server-core.h>
 
-struct _tdm_private_loop {
-       struct wl_display *wl_display;
-       struct wl_event_loop *wl_loop;
-
-       int backend_fd;
-       tdm_event_loop_source *backend_source;
-};
-
 typedef struct _tdm_event_loop_source_base
 {
        struct wl_event_source *wl_source;
@@ -78,7 +70,9 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat
        tdm_private_display *private_display = (tdm_private_display*)user_data;
        tdm_private_loop *private_loop;
        tdm_func_display *func_display;
+       tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(private_display != NULL, TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(private_display->private_loop != NULL, TDM_ERROR_OPERATION_FAILED);
 
@@ -91,13 +85,18 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat
        if (!func_display->display_handle_events)
                return TDM_ERROR_NONE;
 
-       return func_display->display_handle_events(private_display->bdata);
+       ret = func_display->display_handle_events(private_display->bdata);
+
+       return ret;
 }
 
 INTERN tdm_error
 tdm_event_loop_init(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop;
+       tdm_error ret;
+
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
 
        if (private_display->private_loop)
                return TDM_ERROR_NONE;
@@ -116,28 +115,44 @@ tdm_event_loop_init(tdm_private_display *private_display)
                free(private_loop);
                return TDM_ERROR_OUT_OF_MEMORY;
        }
-
        private_loop->wl_loop = wl_display_get_event_loop(private_loop->wl_display);
-       if (!private_loop->wl_loop) {
-               TDM_ERR("no event loop");
+
+       ret = tdm_server_init(private_loop);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("server init failed");
                wl_display_destroy(private_loop->wl_display);
                free(private_loop);
-               return TDM_ERROR_OUT_OF_MEMORY;
+               return TDM_ERROR_OPERATION_FAILED;
        }
 
-       TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
-
+       private_loop->dpy = private_display;
        private_display->private_loop = private_loop;
 
+       ret = tdm_thread_init(private_loop);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("thread init failed");
+               tdm_server_deinit(private_loop);
+               wl_display_destroy(private_loop->wl_display);
+               free(private_loop);
+               return TDM_ERROR_OPERATION_FAILED;
+       }
+
+       TDM_INFO("event loop fd(%d)", wl_event_loop_get_fd(private_loop->wl_loop));
+
        return TDM_ERROR_NONE;
 }
 
 INTERN void
 tdm_event_loop_deinit(tdm_private_display *private_display)
 {
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
        if (!private_display->private_loop)
                return;
 
+       tdm_thread_deinit(private_display->private_loop);
+       tdm_server_deinit(private_display->private_loop);
+
        if (private_display->private_loop->backend_source)
                tdm_event_loop_source_remove(private_display->private_loop->backend_source);
 
@@ -156,6 +171,7 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display)
        tdm_error ret;
        int fd = -1;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
        TDM_RETURN_IF_FAIL(private_loop != NULL);
 
        func_display = &private_display->func_display;
@@ -166,7 +182,7 @@ tdm_event_loop_create_backend_source(tdm_private_display *private_display)
 
        ret = func_display->display_get_fd(private_display->bdata, &fd);
        if (fd < 0) {
-               TDM_WRN("TDM backend module returns fd(%d)", fd);
+               TDM_ERR("TDM backend module returns fd(%d)", fd);
                return;
        }
 
@@ -195,6 +211,8 @@ tdm_event_loop_get_fd(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, -1);
 
        return wl_event_loop_get_fd(private_loop->wl_loop);
@@ -205,6 +223,8 @@ tdm_event_loop_dispatch(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(private_loop->wl_loop != NULL, TDM_ERROR_OPERATION_FAILED);
 
        if (tdm_debug_thread)
@@ -220,30 +240,33 @@ tdm_event_loop_dispatch(tdm_private_display *private_display)
        return TDM_ERROR_NONE;
 }
 
-INTERN tdm_error
-tdm_event_loop_add_socket(tdm_private_display *private_display, const char *name)
+
+INTERN void
+tdm_event_loop_flush(tdm_private_display *private_display)
 {
        tdm_private_loop *private_loop = private_display->private_loop;
 
-       TDM_RETURN_VAL_IF_FAIL(private_loop->wl_display != NULL, TDM_ERROR_OPERATION_FAILED);
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
 
-       if (wl_display_add_socket(private_loop->wl_display, name) < 0) {
-               TDM_ERR("add socket(\"%s\") failed", name);
-               return TDM_ERROR_OPERATION_FAILED;
-       }
+       TDM_RETURN_IF_FAIL(private_loop->wl_display != NULL);
 
-       return TDM_ERROR_NONE;
+       wl_display_flush_clients(private_loop->wl_display);
 }
 
 static int
 _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
 {
        tdm_event_loop_source_fd *fd_source = (tdm_event_loop_source_fd*)data;
+       tdm_private_display *private_display;
        tdm_event_loop_mask mask = 0;
 
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
+
        TDM_RETURN_VAL_IF_FAIL(fd_source, 1);
        TDM_RETURN_VAL_IF_FAIL(fd_source->func, 1);
 
+       private_display = fd_source->private_display;
+
        if (wl_mask & WL_EVENT_READABLE)
                mask |= TDM_EVENT_LOOP_READABLE;
        if (wl_mask & WL_EVENT_WRITABLE)
@@ -253,7 +276,9 @@ _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data)
        if (wl_mask & WL_EVENT_ERROR)
                mask |= TDM_EVENT_LOOP_ERROR;
 
+       _pthread_mutex_lock(&private_display->lock);
        fd_source->func(fd, mask, fd_source->user_data);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return 1;
 }
@@ -269,6 +294,7 @@ tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask
        uint32_t wl_mask = 0;
        tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd >= 0, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
@@ -312,6 +338,7 @@ tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_ma
        tdm_event_loop_source_fd *fd_source = source;
        uint32_t wl_mask = 0;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(fd_source, TDM_ERROR_INVALID_PARAMETER);
 
        if (mask & TDM_EVENT_LOOP_READABLE)
@@ -331,11 +358,18 @@ static int
 _tdm_event_loop_timer_func(void *data)
 {
        tdm_event_loop_source_timer *timer_source = (tdm_event_loop_source_timer*)data;
+       tdm_private_display *private_display;
+
+       /* DON'T check TDM_MUTEX_IS_LOCKED here */
 
        TDM_RETURN_VAL_IF_FAIL(timer_source, 1);
        TDM_RETURN_VAL_IF_FAIL(timer_source->func, 1);
 
+       private_display = timer_source->private_display;
+
+       _pthread_mutex_lock(&private_display->lock);
        timer_source->func(timer_source->user_data);
+       _pthread_mutex_unlock(&private_display->lock);
 
        return 1;
 }
@@ -349,6 +383,7 @@ tdm_event_loop_add_timer_handler(tdm_display *dpy, tdm_event_loop_timer_handler
        tdm_event_loop_source_timer *timer_source;
        tdm_error ret;
 
+       TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL);
        TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL);
 
@@ -385,6 +420,7 @@ tdm_event_loop_source_timer_update(tdm_event_loop_source *source, int ms_delay)
 {
        tdm_event_loop_source_timer *timer_source = source;
 
+       TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
        TDM_RETURN_VAL_IF_FAIL(timer_source, TDM_ERROR_INVALID_PARAMETER);
 
        if (wl_event_source_timer_update(timer_source->base.wl_source, ms_delay) < 0) {
@@ -400,6 +436,8 @@ tdm_event_loop_source_remove(tdm_event_loop_source *source)
 {
        tdm_event_loop_source_base *base = (tdm_event_loop_source_base*)source;
 
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
        if (!base)
                return;