From: joogab.yun Date: Tue, 26 Nov 2024 06:31:22 +0000 (+0900) Subject: [Tizen] Add KeyEventMonitorSignal X-Git-Tag: accepted/tizen/9.0/unified/20241201.053511^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=cdbdd49f924e59190c7b34d3f44a4dcbdadd166c;p=platform%2Fcore%2Fuifw%2Fdali-core.git [Tizen] 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 4a95e648c..d9d2530d8 100644 --- 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(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 37dbe0a1b..2511a65f6 100644 --- 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 7cb3d6baf..011e9e9f0 100644 --- 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 d9c0e138b..7dfb4376d 100644 --- 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 7bd77a524..d7d232d5d 100644 --- 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 5133ea2c6..38c54a344 100644 --- 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 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 dfdcd03b6..a31f5d7f9 100644 --- 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 1f1944afa..b290d5827 100644 --- 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 3b059bca0..ebc3e7776 100644 --- 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 a0337bd6d..4ee3de12b 100644 --- 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(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 3edb0c965..670d188e2 100644 --- 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 fdef9817f..b786ea167 100644 --- 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 /**