virtual: support virtual output create & destroy

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

diff --git a/src/tdm_display.c b/src/tdm_display.c
index 297dd70..4ee693e 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -349,6 +349,124 @@ tdm_display_enable_fps(tdm_private_display *private_display, int enable)
 }
 /* LCOV_EXCL_STOP */
 
+INTERN tdm_error
+tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
+{
+       tdm_thread_cb_display_output_create output_create;
+       tdm_error ret;
+
+       if (LIST_IS_EMPTY(&private_display->output_create_handler_list)) return TDM_ERROR_NONE;
+
+       memset(&output_create, 0, sizeof output_create);
+       output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
+       output_create.base.length = sizeof output_create;
+       output_create.base.object_stamp = tdm_helper_get_time();
+       output_create.base.data = NULL;
+       output_create.base.sync = 1;
+       output_create.output = output;
+
+       ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
+       TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+       return TDM_ERROR_NONE;
+}
+
+INTERN void
+tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
+{
+       tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
+       tdm_private_output_create_handler *create_handler = user_data;
+       TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+       assert(create_handler->owner_tid == syscall(SYS_gettid));
+
+       _pthread_mutex_unlock(&private_display->lock);
+       create_handler->func(private_display, output_create->output, create_handler->user_data);
+       _pthread_mutex_lock(&private_display->lock);
+}
+
+EXTERN tdm_error
+tdm_display_add_output_create_handler(tdm_display *dpy,
+                                                                         tdm_output_create_handler func,
+                                                                         void *user_data)
+{
+       tdm_private_output_create_handler *create_handler = NULL;
+
+       DISPLAY_FUNC_ENTRY();
+
+       TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+       _pthread_mutex_lock(&private_display->lock);
+
+       LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
+               if (create_handler->func == func && create_handler->user_data == user_data) {
+                       TDM_ERR("can't add twice");
+                       _pthread_mutex_unlock(&private_display->lock);
+                       return TDM_ERROR_BAD_REQUEST;
+               }
+       }
+
+       create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
+       if (!create_handler) {
+               TDM_ERR("failed: alloc memory");
+               _pthread_mutex_unlock(&private_display->lock);
+               return TDM_ERROR_OUT_OF_MEMORY;
+       }
+
+       ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+                                                       tdm_display_thread_cb_output_create, create_handler);
+       if (ret != TDM_ERROR_NONE) {
+               TDM_ERR("tdm_thread_cb_add failed");
+               free(create_handler);
+               _pthread_mutex_unlock(&private_display->lock);
+               return TDM_ERROR_OPERATION_FAILED;
+       }
+
+       create_handler->private_display = private_display;
+       create_handler->func = func;
+       create_handler->user_data = user_data;
+       create_handler->owner_tid = syscall(SYS_gettid);
+
+       LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
+
+       _pthread_mutex_unlock(&private_display->lock);
+
+       return ret;
+}
+
+EXTERN void
+tdm_display_remove_output_create_handler(tdm_display *dpy,
+                                                                                tdm_output_create_handler func,
+                                                                                void *user_data)
+{
+       tdm_private_display *private_display;
+       tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
+
+       TDM_RETURN_IF_FAIL(dpy != NULL);
+       TDM_RETURN_IF_FAIL(func != NULL);
+
+       private_display = (tdm_private_display*)dpy;
+
+       _pthread_mutex_lock(&private_display->lock);
+
+       LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
+               if (create_handler->func != func || create_handler->user_data != user_data)
+                       continue;
+
+               tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+                                                        tdm_display_thread_cb_output_create, create_handler);
+
+               LIST_DEL(&create_handler->link);
+               free(create_handler);
+
+               _pthread_mutex_unlock(&private_display->lock);
+
+               return;
+       }
+
+       _pthread_mutex_unlock(&private_display->lock);
+}
+
 EXTERN tdm_error
 tdm_display_get_capabilities(tdm_display *dpy,
                                                         tdm_display_capability *capabilities)