Modified to call key_event_done() last when processing key event from engine-loader

Change-Id: I3cd649a6e16bb185b96ef6f2a01927adceb5f8c8

diff --git a/engine-loader/include/engine_loader.h b/engine-loader/include/engine_loader.h
index 8c690d2..783ede9 100644 (file)
--- a/engine-loader/include/engine_loader.h
+++ b/engine-loader/include/engine_loader.h
@@ -51,7 +51,7 @@ public:
     void flush_imengine();
     void reset_imengine();
     void send_imengine_event(int command, uint32_t value);
-    bool process_key_event(scim::KeyEvent key);
+    void process_key_event(scim::KeyEvent key, uint32_t serial);
     void focus_in();
     void focus_out();
     void update_cursor_position(int cursor_pos);

diff --git a/engine-loader/src/engine_loader.cpp b/engine-loader/src/engine_loader.cpp
index 6e65af2..a4e0d17 100644 (file)
--- a/engine-loader/src/engine_loader.cpp
+++ b/engine-loader/src/engine_loader.cpp
@@ -576,16 +576,28 @@ void EngineLoader::send_imengine_event(int command, uint32_t value)
     }
 }
 
-bool EngineLoader::process_key_event(scim::KeyEvent key)
+void EngineLoader::process_key_event(scim::KeyEvent key, uint32_t serial)
 {
-    uint32 ret = 0;
+    uint32 result = 0;
+    GVariantBuilder *key_event_builder = NULL;
 
     if (!m_impl->si.null()) {
-        ret = m_impl->si->process_key_event(key);
-        SECURE_LOGD ("imengine(%s) process key %u return %d", m_impl->si->get_factory_uuid().c_str(), key.code, ret);
+        result = m_impl->si->process_key_event(key);
+        SECURE_LOGD ("imengine(%s) process key %u return %d", m_impl->si->get_factory_uuid().c_str(), key.code, result);
     }
 
-    return ret == 0 ? false : true;
+    key_event_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+    g_variant_builder_add(key_event_builder, "{sv}", "key_code", g_variant_new_uint32(key.code));
+    g_variant_builder_add(key_event_builder, "{sv}", "key_mask", g_variant_new_uint16(key.mask));
+    g_variant_builder_add(key_event_builder, "{sv}", "key_layout", g_variant_new_uint16(key.layout));
+    g_variant_builder_add(key_event_builder, "{sv}", "key_dev_class", g_variant_new_uint16(key.dev_class));
+    g_variant_builder_add(key_event_builder, "{sv}", "key_dev_subclass", g_variant_new_uint16(key.dev_subclass));
+
+    int ret = engine_loader_send_message(g_variant_new("(a{sv}sub)", key_event_builder, key.dev_name.c_str(), serial, result == 0 ? false : true), "send_processing_result");
+    if (ret != ENGINE_LOADER_ERROR_NONE)
+        LOGE("Failed to send processing result");
+
+    g_variant_builder_unref(key_event_builder);
 }
 
 void EngineLoader::focus_in()

diff --git a/engine-loader/src/engine_loader_dbus.cpp b/engine-loader/src/engine_loader_dbus.cpp
index 27f80b0..e459426 100644 (file)
--- a/engine-loader/src/engine_loader_dbus.cpp
+++ b/engine-loader/src/engine_loader_dbus.cpp
@@ -187,7 +187,7 @@ static int _register_dbus_interface(void)
             "        <method name='process_key_event'>"
             "          <arg type='a{sv}' name='key_event' direction='in'/>"
             "          <arg type='s' name='key_dev_name' direction='in'/>"
-            "          <arg type='b' name='result' direction='out'/>"
+            "          <arg type='u' name='serial' direction='in'/>"
             "        </method>"
 
             "        <method name='focus_in'>"
@@ -487,7 +487,6 @@ int engine_loader_send_imengine_event(GVariant *parameters, GVariant **reply_bod
 
 int engine_loader_process_key_event(GVariant *parameters, GVariant **reply_body)
 {
-    bool result = false;
     uint32_t code = 0;
     uint16_t mask = 0;
     uint16_t layout = 0;
@@ -497,8 +496,9 @@ int engine_loader_process_key_event(GVariant *parameters, GVariant **reply_body)
     GVariantIter *key_event_iter = NULL;
     GVariant *value = NULL;
     gchar *key = NULL;
+    uint32_t serial = 0;
 
-    g_variant_get(parameters, "(a{sv}&s)", &key_event_iter, &dev_name);
+    g_variant_get(parameters, "(a{sv}&su)", &key_event_iter, &dev_name, &serial);
     if (key_event_iter && dev_name) {
         while (g_variant_iter_loop (key_event_iter, "{sv}", &key, &value)) {
             if (g_strcmp0(key, "key_code") == 0)
@@ -527,18 +527,12 @@ int engine_loader_process_key_event(GVariant *parameters, GVariant **reply_body)
         key_event.dev_class = dev_class;
         key_event.dev_subclass = dev_subclass;
 
-        result = m_engine_loader.process_key_event(key_event);
+        m_engine_loader.process_key_event(key_event, serial);
     }
     else {
         LOGW("Failed to get iter");
     }
 
-    *reply_body = g_variant_new("(b)", result);
-    if (*reply_body == NULL) {
-        LOGE("Failed to create reply_body");
-        return ENGINE_LOADER_ERROR_OUT_OF_MEMORY;
-    }
-
     return ENGINE_LOADER_ERROR_NONE;
 }
 

diff --git a/ism/src/scim_helper.cpp b/ism/src/scim_helper.cpp
index 81a76c4..5de663c 100644 (file)
--- a/ism/src/scim_helper.cpp
+++ b/ism/src/scim_helper.cpp
@@ -133,6 +133,9 @@ typedef Signal2<void, const HelperAgent *, LookupTable &>
 typedef Signal3<void, const HelperAgent *, KeyEvent &, uint32 &>
         HelperAgentSignalKeyEventUint;
 
+typedef Signal3<void, const HelperAgent *, KeyEvent &, uint32>
+        HelperAgentSignalKeyEventUint2;
+
 typedef Signal4<void, const HelperAgent *, KeyEvent &, uint32 &, uint32>
         HelperAgentSignalKeyEventUintUint;
 
@@ -238,7 +241,7 @@ public:
     HelperAgentSignalStringVoid         signal_set_mime_type;
     HelperAgentSignalString             signal_set_prediction_hint_data;
     HelperAgentSignalUintVoid           signal_set_optimization_hint;
-    HelperAgentSignalKeyEventUint       signal_process_key_event_with_imengine;
+    HelperAgentSignalKeyEventUint2      signal_process_key_event_with_imengine;
     HelperAgentSignalUintVoid           signal_set_autocapital_type;
     HelperAgentSignalUintVoid           signal_set_prediction_allow;
 
@@ -1173,24 +1176,27 @@ HelperAgent::handle_message (MessageItem *message)
             uint32 keycode_ret = 0;
             m_impl->signal_process_key_event(this, subclass->get_key_ref(), ret);
             m_impl->signal_process_key_event_with_keycode(this, subclass->get_key_ref(), keycode_ret, subclass->get_keycode_ref());
-            if (ret == 0 && keycode_ret == 0) {
+
+            if (ret != 0 && keycode_ret != 0) {
+                ret = 1;
+                m_impl->process_key_event_done (subclass->get_key_ref(), ret, subclass->get_serial_ref());
+            } else {
                 if (!(subclass->get_key_ref().get_key_string().compare("KeyRelease+XF86Back") == 0 ||
                       subclass->get_key_ref().get_key_string().compare("XF86Back") == 0)) {
                         if (m_impl->engine_loader_flag) {
-                            m_impl->signal_process_key_event_with_imengine(this, subclass->get_key_ref(), ret);
-                            SECURE_LOGD ("imengine process key %d return %d", subclass->get_key_ref().code, ret);
+                            m_impl->signal_process_key_event_with_imengine(this, subclass->get_key_ref(), subclass->get_serial_ref());
+                            SECURE_LOGD ("imengine process key %d", subclass->get_key_ref().code);
                         } else {
                             if (!m_impl->si.null ()) {
                                 ret = m_impl->si->process_key_event (subclass->get_key_ref());
                                 SECURE_LOGD ("imengine(%s) process key %d return %d", m_impl->si->get_factory_uuid().c_str(),
                                     subclass->get_key_ref().code, ret);
                             }
+                            m_impl->process_key_event_done (subclass->get_key_ref(), ret, subclass->get_serial_ref());
                         }
-                }
+                } else
+                    m_impl->process_key_event_done (subclass->get_key_ref(), ret, subclass->get_serial_ref());
             }
-            if (ret != keycode_ret)
-                ret = 1;
-            m_impl->process_key_event_done (subclass->get_key_ref(), ret, subclass->get_serial_ref());
             break;
         }
         case ISM_TRANS_CMD_SET_LAYOUT:
@@ -2725,6 +2731,15 @@ HelperAgent::set_engine_loader_flag (bool flag)
     m_impl->engine_loader_flag = flag;
 }
 
+void
+HelperAgent::send_key_event_processing_result (KeyEvent &key,
+                                               uint32          serial,
+                                               bool            is_success) const
+{
+    int ret = is_success ? 1 : 0;
+    m_impl->process_key_event_done (key, ret, serial);
+}
+
 /**
  * @brief Connect a slot to Helper exit signal.
  *
@@ -3641,10 +3656,10 @@ HelperAgent::signal_connect_set_optimization_hint (HelperAgentSlotUintVoid *slot
  * This signal is used to deliver the key event to Helper ISE.
  *
  * The prototype of the slot is:
- * void process_key_event_with_imengine (const HelperAgent *agent, KeyEvent &key, uint32 &ret);
+ * void process_key_event_with_imengine (const HelperAgent *agent, KeyEvent &key, uint32 serial);
  */
 Connection
-HelperAgent::signal_connect_process_key_event_with_imengine (HelperAgentSlotKeyEventUint *slot)
+HelperAgent::signal_connect_process_key_event_with_imengine (HelperAgentSlotKeyEventUint2 *slot)
 {
     return m_impl->signal_process_key_event_with_imengine.connect (slot);
 }

diff --git a/ism/src/scim_helper.h b/ism/src/scim_helper.h
index df4e88d..84ef5e6 100644 (file)
--- a/ism/src/scim_helper.h
+++ b/ism/src/scim_helper.h
@@ -210,8 +210,13 @@ typedef Slot2<void, const HelperAgent *, const std::vector<uint32> &>
 
 typedef Slot2<void, const HelperAgent *, LookupTable &>
         HelperAgentSlotLookupTable;
+
 typedef Slot3<void, const HelperAgent *, KeyEvent &, uint32 &>
         HelperAgentSlotKeyEventUint;
+
+typedef Slot3<void, const HelperAgent *, KeyEvent &, uint32>
+        HelperAgentSlotKeyEventUint2;
+
 typedef Slot4<void, const HelperAgent *, KeyEvent &, uint32 &, uint32>
         HelperAgentSlotKeyEventUintUint;
 
@@ -778,6 +783,10 @@ public:
 
     void set_engine_loader_flag   (bool                          flag);
 
+    void send_key_event_processing_result   (KeyEvent     &key,
+                                             uint32        serial,
+                                             bool          is_success) const;
+
 public:
     /**
      * @brief Connect a slot to Helper exit signal.
@@ -1435,9 +1444,9 @@ public:
      * @brief Connect a slot to Helper process key event with imengine signal.
      *
      * The prototype of the slot is:
-     * void process_key_event_with_imengine (const HelperAgent *, KeyEvent &key, uint32 &ret);
+     * void process_key_event_with_imengine (const HelperAgent *, KeyEvent &key, uint32 serial);
      */
-    Connection signal_connect_process_key_event_with_imengine       (HelperAgentSlotKeyEventUint *slot);
+    Connection signal_connect_process_key_event_with_imengine       (HelperAgentSlotKeyEventUint2       *slot);
 
     /**
      * @brief Connect a slot to Helper set autocapital type signal.