Add KeyEventMonitorSignal

Change-Id: I5f598251bfa1cb1fb6661ded46030c1e0074c62f

diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp
index 4a95e648c92b1f7614f5480c8d0744a13b6ea408..d9d2530d85069303f78bdf5f43cab46c6300ca8f 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Scene.cpp
+++ b/automated-tests/src/dali/utc-Dali-Scene.cpp
@@ -2649,6 +2649,62 @@ int UtcDaliSceneSignalInterceptKeyEventN(void)
   END_TEST;
 }
 
+int UtcDaliSceneSignalKeyEventMonitorP(void)
+{
+  TestApplication          application;
+  Dali::Integration::Scene scene = application.GetScene();
+
+  KeyEventSignalData      data;
+  KeyEventReceivedFunctor functor(data);
+  scene.KeyEventSignal().Connect(&application, functor);
+
+  KeyEventSignalData      monitorData;
+  KeyEventReceivedFunctor monitorFunctor(monitorData);
+  scene.KeyEventMonitorSignal().Connect(&application, monitorFunctor);
+
+  Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  application.ProcessEvent(event);
+
+  DALI_TEST_EQUALS(false, monitorData.functorCalled, TEST_LOCATION);
+  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+
+  data.Reset();
+  monitorData.Reset();
+
+  Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  event3.receiveTime = 330;
+  application.ProcessEvent(event3);
+
+  DALI_TEST_EQUALS(true, monitorData.functorCalled, TEST_LOCATION);
+  DALI_TEST_CHECK(event3.keyModifier == monitorData.receivedKeyEvent.GetKeyModifier());
+  DALI_TEST_CHECK(event3.keyName == monitorData.receivedKeyEvent.GetKeyName());
+  DALI_TEST_CHECK(event3.keyString == monitorData.receivedKeyEvent.GetKeyString());
+  DALI_TEST_CHECK(event3.receiveTime == monitorData.receivedKeyEvent.GetReceiveTime());
+  DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(monitorData.receivedKeyEvent.GetState()));
+  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+
+  data.Reset();
+  monitorData.Reset();
+
+  END_TEST;
+}
+
+int UtcDaliSceneSignalKeyEventMonitorN(void)
+{
+  TestApplication          application;
+  Dali::Integration::Scene scene = application.GetScene();
+
+  KeyEventSignalData      data;
+  KeyEventReceivedFunctor functor(data);
+  scene.KeyEventMonitorSignal().Connect(&application, functor);
+
+  // Check that a non-pressed key events data is not modified.
+  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+
+  END_TEST;
+}
+
+
 int UtcDaliSceneGetOverlayLayer(void)
 {
   TestApplication application;

diff --git a/dali/integration-api/events/key-event-integ.cpp b/dali/integration-api/events/key-event-integ.cpp
index 37dbe0a1ba5224b74a2fc5361daa25cd3133fe08..2511a65f6ca5ce35e3776b49d7240bba17f250fd 100644 (file)
--- a/dali/integration-api/events/key-event-integ.cpp
+++ b/dali/integration-api/events/key-event-integ.cpp
@@ -39,7 +39,8 @@ KeyEvent::KeyEvent()
   deviceClass(Device::Class::NONE),
   deviceSubclass(Device::Subclass::NONE),
   isRepeat(false),
-  windowId(0)
+  windowId(0),
+  receiveTime(0)
 {
 }
 
@@ -67,7 +68,8 @@ KeyEvent::KeyEvent(const std::string&           keyName,
   deviceClass(deviceClass),
   deviceSubclass(deviceSubclass),
   isRepeat(false),
-  windowId(0)
+  windowId(0),
+  receiveTime(0)
 {
 }
 

diff --git a/dali/integration-api/events/key-event-integ.h b/dali/integration-api/events/key-event-integ.h
index 7cb3d6baf247d8914aeaf43a312a6fc89315361e..011e9e9f0b32ebfff9b330618eb4e998f30755fb 100644 (file)
--- a/dali/integration-api/events/key-event-integ.h
+++ b/dali/integration-api/events/key-event-integ.h
@@ -147,6 +147,12 @@ struct DALI_CORE_API KeyEvent : public Event
    * Window id where key event occurred.
    */
   uint32_t windowId;
+
+  /**
+   * The time (in ms)  when key event was received.
+   */
+  uint32_t receiveTime;
+
 };
 
 } // namespace Integration

diff --git a/dali/integration-api/scene.cpp b/dali/integration-api/scene.cpp
index d9c0e138bf81335404b15ec8ac2277d38fb00732..7dfb4376dd554777c9a1a57f26d10128f7d1bc30 100644 (file)
--- a/dali/integration-api/scene.cpp
+++ b/dali/integration-api/scene.cpp
@@ -293,6 +293,11 @@ Scene::KeyEventGeneratedSignalType& Scene::InterceptKeyEventSignal()
   return GetImplementation(*this).InterceptKeyEventSignal();
 }
 
+Scene::KeyEventSignalType& Scene::KeyEventMonitorSignal()
+{
+  return GetImplementation(*this).KeyEventMonitorSignal();
+}
+
 Scene::TouchEventSignalType& Scene::TouchedSignal()
 {
   return GetImplementation(*this).TouchedSignal();

diff --git a/dali/integration-api/scene.h b/dali/integration-api/scene.h
index 7bd77a5249466e45ef870a144343813492b3084b..d7d232d5d5ba99465397373afe0106a6f6a8ff22 100644 (file)
--- a/dali/integration-api/scene.h
+++ b/dali/integration-api/scene.h
@@ -538,6 +538,20 @@ public:
    */
   KeyEventGeneratedSignalType& InterceptKeyEventSignal();
 
+  /**
+   * @brief The user would connect to this signal to monitor a KeyEvent at window.
+   * This signal is emitted when KeyEvent is generated.
+   *
+   * A Callback of the following type may be connected:
+   * @code
+   *  bool YourCallbackName(const KeyEvent& event);
+   * @endcode
+   *
+   * @return The signal to connect to
+   */
+  KeyEventSignalType& KeyEventMonitorSignal();
+
+
   /**
    * @brief This signal is emitted when the screen is touched and when the touch ends
    * (i.e. the down & up touch events only).

diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp
index 5133ea2c668675902c5d3d935a45e8ffd41f3554..38c54a3441c3577b0c4ae5e101aefadf5061b18e 100644 (file)
--- a/dali/internal/event/common/scene-impl.cpp
+++ b/dali/internal/event/common/scene-impl.cpp
@@ -494,6 +494,15 @@ bool Scene::EmitWheelEventGeneratedSignal(const Dali::WheelEvent& event)
   return mWheelEventGeneratedSignal.Emit(event);
 }
 
+void Scene::EmitKeyEventMonitorSignal(const Dali::KeyEvent& event)
+{
+  if(!mKeyEventMonitorSignal.Empty())
+  {
+    Dali::Integration::Scene handle(this);
+    mKeyEventMonitorSignal.Emit(event);
+  }
+}
+
 void Scene::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
 {
   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
@@ -591,6 +600,11 @@ Integration::Scene::KeyEventGeneratedSignalType& Scene::InterceptKeyEventSignal(
   return mInterceptKeyEventSignal;
 }
 
+Integration::Scene::KeyEventSignalType& Scene::KeyEventMonitorSignal()
+{
+  return mKeyEventMonitorSignal;
+}
+
 Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 {
   return mEventProcessingFinishedSignal;

diff --git a/dali/internal/event/common/scene-impl.h b/dali/internal/event/common/scene-impl.h
index dfdcd03b61b5b59771935f41261c714fd9cd18a9..a31f5d7f985f6d9679f43cff81a40f741734e78a 100644 (file)
--- a/dali/internal/event/common/scene-impl.h
+++ b/dali/internal/event/common/scene-impl.h
@@ -339,6 +339,12 @@ public:
    */
   bool EmitWheelEventGeneratedSignal(const Dali::WheelEvent& event);
 
+  /**
+   * Used by the EventProcessor to emit key event monitor signals.
+   * @param[in] event The key event.
+   */
+  void EmitKeyEventMonitorSignal(const Dali::KeyEvent& event);
+
   /**
    * @copydoc Dali::Integration::Scene::AddFrameRenderedCallback
    */
@@ -389,6 +395,11 @@ public:
    */
   Integration::Scene::KeyEventGeneratedSignalType& InterceptKeyEventSignal();
 
+  /**
+   * @copydoc Integration::Scene::KeyEventSignal()
+   */
+  Integration::Scene::KeyEventSignalType& KeyEventMonitorSignal();
+
   /**
    * @copydoc Integration::Scene::SignalEventProcessingFinished()
    */
@@ -495,6 +506,7 @@ private:
   Integration::Scene::KeyEventSignalType          mKeyEventSignal;
   Integration::Scene::KeyEventGeneratedSignalType mKeyEventGeneratedSignal;
   Integration::Scene::KeyEventGeneratedSignalType mInterceptKeyEventSignal;
+  Integration::Scene::KeyEventSignalType          mKeyEventMonitorSignal;
 
   // The event processing finished signal
   Integration::Scene::EventProcessingFinishedSignalType mEventProcessingFinishedSignal;
@@ -505,6 +517,7 @@ private:
   // The wheel event signal
   Integration::Scene::WheelEventSignalType          mWheelEventSignal;
   Integration::Scene::WheelEventGeneratedSignalType mWheelEventGeneratedSignal;
+
 };
 
 } // namespace Internal

diff --git a/dali/internal/event/events/key-event-impl.cpp b/dali/internal/event/events/key-event-impl.cpp
index 1f1944afa4900a5b96c4f8792e231995885dfd2a..b290d5827511662082f8d2327c4cb00ab69ab5c5 100644 (file)
--- a/dali/internal/event/events/key-event-impl.cpp
+++ b/dali/internal/event/events/key-event-impl.cpp
@@ -47,7 +47,8 @@ KeyEvent::KeyEvent()
   mDeviceClass(Device::Class::NONE),
   mDeviceSubclass(Device::Subclass::NONE),
   mIsRepeat(false),
-  mWindowId(0)
+  mWindowId(0),
+  mReceiveTime(0)
 {
 }
 
@@ -74,7 +75,8 @@ KeyEvent::KeyEvent(const std::string&           keyName,
   mDeviceClass(deviceClass),
   mDeviceSubclass(deviceSubclass),
   mIsRepeat(false),
-  mWindowId(0)
+  mWindowId(0),
+  mReceiveTime(0)
 {
 }
 
@@ -185,6 +187,11 @@ uint32_t KeyEvent::GetWindowId() const
   return mWindowId;
 }
 
+uint32_t KeyEvent::GetReceiveTime() const
+{
+  return mReceiveTime;
+}
+
 void KeyEvent::SetKeyName(const std::string& keyName)
 {
   mKeyName = keyName;
@@ -237,6 +244,11 @@ void KeyEvent::SetWindowId(uint32_t windowId)
   mWindowId = windowId;
 }
 
+void KeyEvent::SetReceiveTime(uint32_t time)
+{
+  mReceiveTime = time;
+}
+
 } // namespace Internal
 
 } // namespace Dali

diff --git a/dali/internal/event/events/key-event-impl.h b/dali/internal/event/events/key-event-impl.h
index 3b059bca0695a561bec76c801f6a366fdad6cc88..ebc3e7776e079a3f6ca6bf3a87a760d692a876f6 100644 (file)
--- a/dali/internal/event/events/key-event-impl.h
+++ b/dali/internal/event/events/key-event-impl.h
@@ -186,6 +186,11 @@ public:
    */
   uint32_t GetWindowId() const;
 
+  /**
+   * @copydoc Dali::KeyEvent::GetReceiveTime()
+   */
+  uint32_t GetReceiveTime() const;
+
   /**
    * @brief Set the name given to the key pressed
    *
@@ -249,6 +254,12 @@ public:
    */
   void SetWindowId(uint32_t windowId);
 
+  /**
+   * @brief Sets the time when the key event was received.
+   *
+   * @param[in] receiveTime The time when the key event was received.
+   */
+  void SetReceiveTime(uint32_t receiveTime);
 
 private:
   /**
@@ -279,6 +290,7 @@ private:
   Device::Subclass::Type mDeviceSubclass; ///< The subclass of device the key event originated from
   bool                   mIsRepeat;       ///< Whether the key referenced by the event is a repeating key.
   uint32_t               mWindowId;       ///< The window id where key event occurred.
+  uint32_t               mReceiveTime;    ///< The time when the key event was received.
 };
 
 } // namespace Internal

diff --git a/dali/internal/event/events/key-event-processor.cpp b/dali/internal/event/events/key-event-processor.cpp
index a0337bd6da3870669701e33152137a6b172dda61..4ee3de12bea2987351776e32e569a9d21f5d6047 100644 (file)
--- a/dali/internal/event/events/key-event-processor.cpp
+++ b/dali/internal/event/events/key-event-processor.cpp
@@ -36,6 +36,8 @@ namespace Internal
 {
 namespace
 {
+const uint32_t DEFAULT_MONITOR_KEY_EVENT_TIME = 330u;
+
 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
 
 #ifdef TRACE_ENABLED
@@ -59,12 +61,20 @@ void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
   KeyEventPtr    keyEvent(new KeyEvent(event.keyName, event.logicalKey, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<Dali::KeyEvent::State>(event.state), event.compose, event.deviceName, event.deviceClass, event.deviceSubclass));
   keyEvent->SetRepeat(event.isRepeat);
   keyEvent->SetWindowId(event.windowId);
+  keyEvent->SetReceiveTime(event.receiveTime);
+
   Dali::KeyEvent keyEventHandle(keyEvent.Get());
 
   DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_PROCESS_KEY_EVENT", [&](std::ostringstream& oss) {
-    oss << "[name:" << event.keyName << ", code:" << event.keyCode << ", state:" << KEY_EVENT_STATES[event.state] << ", time:" << event.time << "]";
+    oss << "[name:" << event.keyName << ", code:" << event.keyCode << ", state:" << KEY_EVENT_STATES[event.state] << ", time:" << event.time << ", recieveTime:" << event.receiveTime << "]";
   });
 
+  if(event.receiveTime > 0 && (event.receiveTime >= event.time + DEFAULT_MONITOR_KEY_EVENT_TIME))
+  {
+    DALI_LOG_RELEASE_INFO("KeyEvent is delayed : occurred time %d ms, received time %d ms \n", event.time, event.receiveTime);
+    mScene.EmitKeyEventMonitorSignal(keyEventHandle);
+  }
+
   // Emit the key event signal from the scene.
   bool consumed = false;
   if(!keyEventHandle.IsNoInterceptModifier())

diff --git a/dali/public-api/events/key-event.cpp b/dali/public-api/events/key-event.cpp
index 3edb0c9652ba79bbe415634e0458896935891763..670d188e28c292da0e6830ddc6771644e67487a9 100644 (file)
--- a/dali/public-api/events/key-event.cpp
+++ b/dali/public-api/events/key-event.cpp
@@ -123,6 +123,11 @@ uint32_t KeyEvent::GetWindowId() const
   return GetImplementation(*this).GetWindowId();
 }
 
+uint32_t KeyEvent::GetReceiveTime() const
+{
+  return GetImplementation(*this).GetReceiveTime();
+}
+
 KeyEvent::KeyEvent(Internal::KeyEvent* internal)
 : BaseHandle(internal)
 {

diff --git a/dali/public-api/events/key-event.h b/dali/public-api/events/key-event.h
index fdef9817fd27d3bc3afd4772cff9190a5253525e..b786ea167976b139f0c0c2cd3052344d6cb5caf4 100644 (file)
--- a/dali/public-api/events/key-event.h
+++ b/dali/public-api/events/key-event.h
@@ -263,6 +263,12 @@ public:
    */
   uint32_t GetWindowId() const;
 
+  /**
+   * @brief Gets the time when the key event was received.
+   * @SINCE_2_3.52
+   */
+  uint32_t GetReceiveTime() const;
+
 public: // Not intended for application developers
   /// @cond internal
   /**