libaurum: integrate to use a ecore main loop

tizen service app uses ecore main loop.
and efl_util* works in the loop.
this patch modifies it to use ecore main loop.

Change-Id: I6a937a7820a89371b2e081739cb4cdf974f394cf

diff --git a/libaurum/src/DeviceImpl/TizenImpl.cc b/libaurum/src/DeviceImpl/TizenImpl.cc
index 0bf661f..29cf7db 100644 (file)
--- a/libaurum/src/DeviceImpl/TizenImpl.cc
+++ b/libaurum/src/DeviceImpl/TizenImpl.cc
@@ -1,27 +1,36 @@
 #include "DeviceImpl/TizenImpl.h"
 
-#include <stdlib.h>
-#include <iostream>
+#include <functional>
+#include <tuple>
 
 #include <stdlib.h>
+#include <iostream>
+#include <Ecore.h>
 #include "loguru.hpp"
 
 TizenImpl::TizenImpl()
 {
     LOG_SCOPE_F(INFO, "device implementation init");
 #ifdef GBSBUILD
-    mFakeTouchHandle =
-        efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
-    mFakeKeyboardHandle =
-        efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj = static_cast<TizenImpl*>(data);
+        obj->mFakeTouchHandle = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+        obj->mFakeKeyboardHandle =
+            efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+    }, this);
 #endif
+
 }
 
 TizenImpl::~TizenImpl()
 {
 #ifdef GBSBUILD
-    efl_util_input_deinitialize_generator(mFakeTouchHandle);
-    efl_util_input_deinitialize_generator(mFakeKeyboardHandle);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj = static_cast<TizenImpl*>(data);
+        efl_util_input_deinitialize_generator(obj->mFakeTouchHandle);
+        efl_util_input_deinitialize_generator(obj->mFakeKeyboardHandle);
+        return NULL;
+    }, this);
 #endif
 }
 
@@ -34,11 +43,20 @@ bool TizenImpl::click(const int x, const int y, const unsigned int intv)
 {
 LOG_SCOPE_F(INFO, "click at (%d, %d)", x, y);
 #ifdef GBSBUILD
-    efl_util_input_generate_touch(mFakeTouchHandle, 0,
-                                  EFL_UTIL_INPUT_TOUCH_BEGIN, x, y);
-    usleep(intv*10000);
-    efl_util_input_generate_touch(mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
-                                  x, y);
+    auto args = std::make_tuple(this, x, y, intv);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        int x, y;
+        unsigned int intv;
+        std::tie(obj, x, y, intv) = *static_cast<std::tuple<TizenImpl*, int, int, unsigned int>*>(data);
+
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0,
+                                    EFL_UTIL_INPUT_TOUCH_BEGIN, x, y);
+        usleep(intv*10000);
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
+                                    x, y);
+        return NULL;
+    }, (void*)(&args));
     return true;
 #else
     return false;
@@ -50,8 +68,16 @@ bool TizenImpl::touchDown(const int x, const int y)
 {
 #ifdef GBSBUILD
     LOG_F(INFO, "%d %d", x, y);
-    efl_util_input_generate_touch(mFakeTouchHandle, 0,
-                                  EFL_UTIL_INPUT_TOUCH_BEGIN, x, y);
+    auto args = std::make_tuple(this, x, y);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        int x, y;
+        std::tie(obj, x, y) = *static_cast<std::tuple<TizenImpl*, int, int>*>(data);
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_BEGIN,
+                                  x, y);
+
+        return NULL;
+    }, (void*)(&args));
 #endif
     return true;
 }
@@ -60,8 +86,17 @@ bool TizenImpl::touchMove(const int x, const int y)
 {
 #ifdef GBSBUILD
     LOG_F(INFO, "%d %d", x, y);
-    efl_util_input_generate_touch(mFakeTouchHandle, 0,
-                                  EFL_UTIL_INPUT_TOUCH_UPDATE, x, y);
+    auto args = std::make_tuple(this, x, y);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        int x, y;
+        std::tie(obj, x, y) = *static_cast<std::tuple<TizenImpl*, int, int>*>(data);
+
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_UPDATE,
+                                  x, y);
+
+        return NULL;
+    }, (void*)(&args));
 #endif
     return true;
 }
@@ -69,39 +104,59 @@ bool TizenImpl::touchMove(const int x, const int y)
 bool TizenImpl::touchUp(const int x, const int y)
 {
 #ifdef GBSBUILD
-    LOG_F(INFO, "%d %d", x, y);
-    efl_util_input_generate_touch(mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
+    LOG_F(INFO, "touch up %d %d", x, y);
+    auto args = std::make_tuple(this, x, y);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        int x, y;
+        std::tie(obj, x, y) = *static_cast<std::tuple<TizenImpl*, int, int>*>(data);
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
                                   x, y);
-#endif
+
+        return NULL;
+    }, (void*)(&args));
+
     return true;
+#endif
+    return false;
 }
 
 bool TizenImpl::drag(const int sx, const int sy, const int ex, const int ey,
                          const int duration)
 {
 #ifdef GBSBUILD
-    int i, j;
-    int dur;
-    // TODO fixed fps implementation
-    if (duration < 10) dur = 10;
-    else dur = duration;
-
-    i = sx, j = sy;
-    LOG_SCOPE_F(INFO, "flicking (%d, %d)", i, j);
-
-    efl_util_input_generate_touch(mFakeTouchHandle, 0,
-                                  EFL_UTIL_INPUT_TOUCH_BEGIN, i, j);
-    for (; i <= ex && j <= ey; i += (ex - sx) / 10, j += (ey - sy) / 10) {
-        efl_util_input_generate_touch(mFakeTouchHandle, 0,
-                                      EFL_UTIL_INPUT_TOUCH_UPDATE, i, j);
-        usleep(dur * 1000);
+    auto args = std::make_tuple(this, sx, sy, ex, ey, duration);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        int sx, sy, ex, ey, duration;
+        std::tie(obj, sx, sy, ex, ey, duration) = *static_cast<std::tuple<TizenImpl*, int, int, int, int, int>*>(data);
+
+        int i, j;
+        int dur;
+        // TODO fixed fps implementation
+        if (duration < 10) dur = 10;
+        else dur = duration;
+
+        i = sx, j = sy;
         LOG_SCOPE_F(INFO, "flicking (%d, %d)", i, j);
-    }
-    LOG_SCOPE_F(INFO, "flicking (%d, %d)", i, j);
-    efl_util_input_generate_touch(mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
-                                  i, j);
-#endif
+
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0,
+                                        EFL_UTIL_INPUT_TOUCH_BEGIN, i, j);
+        for (; i <= ex && j <= ey; i += (ex - sx) / 10, j += (ey - sy) / 10) {
+            efl_util_input_generate_touch(obj->mFakeTouchHandle, 0,
+                                            EFL_UTIL_INPUT_TOUCH_UPDATE, i, j);
+            usleep(dur * 1000);
+            LOG_SCOPE_F(INFO, "flicking (%d, %d)", i, j);
+        }
+        LOG_SCOPE_F(INFO, "flicking (%d, %d)", i, j);
+        efl_util_input_generate_touch(obj->mFakeTouchHandle, 0, EFL_UTIL_INPUT_TOUCH_END,
+                                        i, j);
+
+        return NULL;
+    }, (void*)(&args));
     return true;
+#endif
+    return false;
 }
 
 bool TizenImpl::pressBack()
@@ -137,8 +192,17 @@ bool TizenImpl::pressPower()
 bool TizenImpl::pressKeyCode(std::string keycode)
 {
 #ifdef GBSBUILD
-    efl_util_input_generate_key(mFakeKeyboardHandle, keycode.c_str(), 1);
-    efl_util_input_generate_key(mFakeKeyboardHandle, keycode.c_str(), 0);
+    auto args = std::make_tuple(this, keycode);
+    ecore_main_loop_thread_safe_call_sync([](void *data)->void*{
+        TizenImpl *obj;
+        std::string keycode;
+        std::tie(obj, keycode) = *static_cast<std::tuple<TizenImpl*, std::string>*>(data);
+
+        efl_util_input_generate_key(obj->mFakeKeyboardHandle, keycode.c_str(), 1);
+        efl_util_input_generate_key(obj->mFakeKeyboardHandle, keycode.c_str(), 0);
+
+        return NULL;
+    }, (void*)(&args));
 #endif
     return true;
 }

diff --git a/misc/setup_device.sh b/misc/setup_device.sh
index 807642a..4f665da 100755 (executable)
--- a/misc/setup_device.sh
+++ b/misc/setup_device.sh
@@ -1,6 +1,4 @@
 #!/bin/bash
-
 sdb forward --remove-all
 sdb forward tcp:50051 tcp:50051
-sdb shell 'su - owner -c "systemctl --user start aurum-bootstrap"'
-sdb shell "ps -ef | grep aurum-bootstrap"
+sdb shell app_launcher -s org.tizen.aurum-bootstrap

diff --git a/org.tizen.aurum-bootstrap/src/BootstrapServer.cc b/org.tizen.aurum-bootstrap/src/BootstrapServer.cc
index ad1db18..1e1169a 100644 (file)
--- a/org.tizen.aurum-bootstrap/src/BootstrapServer.cc
+++ b/org.tizen.aurum-bootstrap/src/BootstrapServer.cc
@@ -60,20 +60,20 @@ void service_app_terminate(void *data)
     g_thread_join(ctx->thread);
 }
 
-void service_app_control(app_control_h app_control, void *data) 
+void service_app_control(app_control_h app_control, void *data)
 {
     ServiceContext *ctx = (ServiceContext*)data;
 }
 
 int main(int argc, char **argv)
 {
-    service_app_lifecycle_callback_s event_callback;  
+    service_app_lifecycle_callback_s event_callback;
     app_event_handler_h handlers[5] = {NULL, };
-    ServiceContext ctx = {0,};    
-                                                  
-    event_callback.create = service_app_create;       
-    event_callback.terminate = service_app_terminate; 
-    event_callback.app_control = service_app_control; 
+    ServiceContext ctx = {0,};
+
+    event_callback.create = service_app_create;
+    event_callback.terminate = service_app_terminate;
+    event_callback.app_control = service_app_control;
 
     return service_app_main(argc, argv, &event_callback, &ctx);
 }