delete redundant input listener

Signed-off-by: xiahaiqin <xiahaiqin1@huawei.com>
Change-Id: I6a5d7ff8f964e2a385f861a4ad8eafe95a164711

interfaces/innerkits/wm/window.h

@@ -25,7 +25,6 @@
 class NativeValue;
 class NativeEngine;
 namespace OHOS::MMI {
-    struct IInputEventConsumer;
     class PointerEvent;
     class KeyEvent;
     class AxisEvent;
@@ -116,14 +115,10 @@ public:
     virtual uint32_t GetBackgroundColor() = 0;
 };
 
-class IInputEventListener : virtual public RefBase {
-public:
-    virtual void OnKeyEvent(std::shared_ptr<MMI::KeyEvent>& keyEvent) = 0;
-    virtual void OnPointerInputEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent) = 0;
-};
-
 class IInputEventConsumer {
 public:
+    IInputEventConsumer() = default;
+    virtual ~IInputEventConsumer() = default;
     virtual bool OnInputEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const = 0;
     virtual bool OnInputEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) const = 0;
     virtual bool OnInputEvent(const std::shared_ptr<MMI::AxisEvent>& axisEvent) const = 0;
@@ -216,9 +211,7 @@ public:
 
     virtual WMError RequestFocus() const = 0;
     virtual WMError UpdateSurfaceNodeAfterCustomAnimation(bool isAdd) = 0;
-    // AddInputEventListener is for api 7
     virtual void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) = 0;
-    virtual void AddInputEventListener(const std::shared_ptr<MMI::IInputEventConsumer>& inputEventListener) = 0;
     virtual void ConsumeKeyEvent(std::shared_ptr<MMI::KeyEvent>& inputEvent) = 0;
     virtual void ConsumePointerEvent(std::shared_ptr<MMI::PointerEvent>& inputEvent) = 0;
     virtual void RequestFrame() = 0;
@@ -234,8 +227,6 @@ public:
     virtual void UnregisterDragListener(const sptr<IWindowDragListener>& listener) = 0;
     virtual void RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) = 0;
     virtual void UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) = 0;
-    virtual void RegisterInputEventListener(const sptr<IInputEventListener>& listener) = 0;
-    virtual void UnregisterInputEventListener(const sptr<IInputEventListener>& listener) = 0;
     virtual void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) = 0;
     virtual void RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) = 0;
     virtual void UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) = 0;

wm/include/window_impl.h

@@ -172,7 +172,6 @@ public:
     virtual void StartMove() override;
 
     virtual WMError RequestFocus() const override;
-    virtual void AddInputEventListener(const std::shared_ptr<MMI::IInputEventConsumer>& inputEventListener) override;
     virtual void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) override;
 
     virtual void RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override;
@@ -185,8 +184,6 @@ public:
     virtual void UnregisterDragListener(const sptr<IWindowDragListener>& listener) override;
     virtual void RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override;
     virtual void UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override;
-    virtual void RegisterInputEventListener(const sptr<IInputEventListener>& listener) override;
-    virtual void UnregisterInputEventListener(const sptr<IInputEventListener>& listener) override;
     virtual void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) override;
     virtual void RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override;
     virtual void UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override;
@@ -210,15 +207,6 @@ public:
     void UpdateDisplayId(DisplayId from, DisplayId to);
     void UpdateOccupiedAreaChangeInfo(const sptr<OccupiedAreaChangeInfo>& info);
     void UpdateActiveStatus(bool isActive);
-    void NotifyOutsidePressed();
-    void NotifySizeChange(Rect rect, WindowSizeChangeReason reason);
-    void NotifyKeyEvent(std::shared_ptr<MMI::KeyEvent> &keyEvent);
-    void NotifyPointEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent);
-    void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type);
-    void NotifyDisplayMoveChange(DisplayId from, DisplayId to);
-    void NotifyOccupiedAreaChange(const sptr<OccupiedAreaChangeInfo>& info);
-    void NotifyModeChange(WindowMode mode);
-    void NotifyDragEvent(const PointInfo& point, DragEvent event);
     void NotifyTouchOutside();
 
     virtual WMError SetUIContent(const std::string& contentInfo, NativeEngine* engine,
@@ -321,6 +309,12 @@ private:
             CALL_LIFECYCLE_LISTENER(ForegroundInvalidMode);
         });
     }
+    void NotifySizeChange(Rect rect, WindowSizeChangeReason reason);
+    void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type);
+    void NotifyDisplayMoveChange(DisplayId from, DisplayId to);
+    void NotifyOccupiedAreaChange(const sptr<OccupiedAreaChangeInfo>& info);
+    void NotifyModeChange(WindowMode mode);
+    void NotifyDragEvent(const PointInfo& point, DragEvent event);
     void DestroyFloatingWindow();
     void DestroySubWindow();
     void SetDefaultOption(); // for api7
@@ -381,7 +375,6 @@ private:
     std::vector<sptr<IWindowDragListener>> windowDragListeners_;
     std::vector<sptr<IDisplayMoveListener>> displayMoveListeners_;
     std::vector<sptr<IOccupiedAreaChangeListener>> occupiedAreaChangeListeners_;
-    std::vector<sptr<IInputEventListener>> inputEventListeners_;
     std::shared_ptr<IInputEventConsumer> inputEventConsumer_;
     sptr<IAnimationTransitionController> animationTranistionController_;
     NotifyNativeWinDestroyFunc notifyNativefunc_;

wm/src/window_impl.cpp

@@ -1457,11 +1457,6 @@ void WindowImpl::SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer
     inputEventConsumer_ = inputEventConsumer;
 }
 
-void WindowImpl::AddInputEventListener(const std::shared_ptr<MMI::IInputEventConsumer>& inputEventListener)
-{
-    InputTransferStation::GetInstance().SetInputListener(GetWindowId(), inputEventListener);
-}
-
 void WindowImpl::RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener)
 {
     if (listener == nullptr) {
@@ -1591,30 +1586,6 @@ void WindowImpl::UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& liste
     displayMoveListeners_.erase(iter);
 }
 
-void WindowImpl::RegisterInputEventListener(const sptr<IInputEventListener>& listener)
-{
-    if (listener == nullptr) {
-        return;
-    }
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    if (std::find(inputEventListeners_.begin(), inputEventListeners_.end(), listener) != inputEventListeners_.end()) {
-        WLOGFE("Listener already registered");
-        return;
-    }
-    inputEventListeners_.emplace_back(listener);
-}
-
-void WindowImpl::UnregisterInputEventListener(const sptr<IInputEventListener>& listener)
-{
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    auto iter = std::find(inputEventListeners_.begin(), inputEventListeners_.end(), listener);
-    if (iter == inputEventListeners_.end()) {
-        WLOGFE("could not find the listener");
-        return;
-    }
-    inputEventListeners_.erase(iter);
-}
-
 void WindowImpl::RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func)
 {
     WLOGFI("JS RegisterWindowDestroyedListener the listener");
@@ -1776,9 +1747,6 @@ void WindowImpl::HandleBackKeyPressedEvent(const std::shared_ptr<MMI::KeyEvent>&
     if (inputEventConsumer != nullptr) {
         WLOGFI("Transfer back key event to inputEventConsumer");
         isConsumed = inputEventConsumer->OnInputEvent(keyEvent);
-    } else if (!inputEventListeners_.empty()) {
-        WLOGFI("inputEventListeners_ is not empty");
-        return;
     } else if (uiContent_ != nullptr) {
         WLOGFI("Transfer back key event to uiContent");
         isConsumed = uiContent_->ProcessBackPressed();
@@ -1810,7 +1778,6 @@ void WindowImpl::HandleBackKeyPressedEvent(const std::shared_ptr<MMI::KeyEvent>&
 
 void WindowImpl::ConsumeKeyEvent(std::shared_ptr<MMI::KeyEvent>& keyEvent)
 {
-    NotifyKeyEvent(keyEvent);
     int32_t keyCode = keyEvent->GetKeyCode();
     int32_t keyAction = keyEvent->GetKeyAction();
     WLOGFI("KeyCode: %{public}d, action: %{public}d", keyCode, keyAction);
@@ -2169,7 +2136,6 @@ void WindowImpl::ConsumePointerEvent(std::shared_ptr<MMI::PointerEvent>& pointer
         WLOGFI("update pointer event for stretchable window");
         UpdatePointerEventForStretchableWindow(pointerEvent);
     }
-    NotifyPointEvent(pointerEvent);
     std::shared_ptr<IInputEventConsumer> inputEventConsumer;
     {
         std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -2379,38 +2345,6 @@ void WindowImpl::NotifySizeChange(Rect rect, WindowSizeChangeReason reason)
     });
 }
 
-void WindowImpl::NotifyKeyEvent(std::shared_ptr<MMI::KeyEvent> &keyEvent)
-{
-    std::vector<sptr<IInputEventListener>> inputEventListeners;
-    {
-        std::lock_guard<std::recursive_mutex> lock(mutex_);
-        inputEventListeners = inputEventListeners_;
-    }
-    PostListenerTask([this, inputEventListeners, keyEvent]() mutable {
-        for (auto& listener : inputEventListeners) {
-            if (listener != nullptr) {
-                listener->OnKeyEvent(keyEvent);
-            }
-        }
-    });
-}
-
-void WindowImpl::NotifyPointEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent)
-{
-    std::vector<sptr<IInputEventListener>> inputEventListeners;
-    {
-        std::lock_guard<std::recursive_mutex> lock(mutex_);
-        inputEventListeners = inputEventListeners_;
-    }
-    PostListenerTask([this, inputEventListeners, pointerEvent]() mutable {
-        for (auto& listener : inputEventListeners) {
-            if (listener != nullptr) {
-                listener->OnPointerInputEvent(pointerEvent);
-            }
-        }
-    });
-}
-
 void WindowImpl::NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type)
 {
     std::vector<sptr<IAvoidAreaChangedListener>> avoidAreaChangeListeners;

wmserver/include/inner_window.h

@@ -28,13 +28,10 @@ public:
     virtual void Destroy() = 0;
 };
 
-class PlaceholderWindowListener : public IWindowLifeCycle, public ITouchOutsideListener, public IInputEventListener {
+class PlaceholderWindowListener : public IWindowLifeCycle, public ITouchOutsideListener {
 public:
     // touch outside listener
     virtual void OnTouchOutside() const;
-    // input event listener
-    virtual void OnKeyEvent(std::shared_ptr<MMI::KeyEvent>& keyEvent);
-    virtual void OnPointerInputEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent);
     // lifecycle listener
     virtual void AfterUnfocused();
     // lifecycle do nothing
@@ -44,6 +41,14 @@ public:
     virtual void AfterInactive() {};
 };
 
+class PlaceholderInputEventConsumer : public IInputEventConsumer {
+public:
+    ~PlaceholderInputEventConsumer() override = default;
+    virtual bool OnInputEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const override;
+    virtual bool OnInputEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) const override;
+    virtual bool OnInputEvent(const std::shared_ptr<MMI::AxisEvent>& axisEvent) const override;
+};
+
 class PlaceHolderWindow : public IInnerWindow {
 WM_DECLARE_SINGLE_INSTANCE(PlaceHolderWindow);
 public:
@@ -51,12 +56,14 @@ public:
     virtual void Destroy();
 
 private:
-    void RegitsterWindowListener();
-    void UnRegitsterWindowListener();
+    void RegisterWindowListener();
+    void UnRegisterWindowListener();
+    void SetInputEventConsumer();
 
 private:
     sptr<OHOS::Rosen::Window> window_;
-    sptr<PlaceholderWindowListener> listener_;
+    sptr<PlaceholderWindowListener> windowListener_;
+    std::shared_ptr<IInputEventConsumer> inputEventConsumer_;
 };
 
 class DividerWindow : public IInnerWindow {

wmserver/src/inner_window.cpp

@@ -34,24 +34,32 @@ void PlaceholderWindowListener::OnTouchOutside() const
     PlaceHolderWindow::GetInstance().Destroy();
 }
 
-void PlaceholderWindowListener::OnKeyEvent(std::shared_ptr<MMI::KeyEvent>& keyEvent)
-{
-    WLOGFD("place holder get key event");
-    PlaceHolderWindow::GetInstance().Destroy();
-}
-
-void PlaceholderWindowListener::OnPointerInputEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent)
-{
-    WLOGFD("place holder get point event");
-    PlaceHolderWindow::GetInstance().Destroy();
-}
-
 void PlaceholderWindowListener::AfterUnfocused()
 {
     WLOGFD("place holder after unfocused");
     PlaceHolderWindow::GetInstance().Destroy();
 }
 
+bool PlaceholderInputEventConsumer::OnInputEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const
+{
+    WLOGFD("place holder get key event");
+    PlaceHolderWindow::GetInstance().Destroy();
+    return true;
+}
+
+bool PlaceholderInputEventConsumer::OnInputEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) const
+{
+    WLOGFD("place holder get point event");
+    PlaceHolderWindow::GetInstance().Destroy();
+    return true;
+}
+
+bool PlaceholderInputEventConsumer::OnInputEvent(const std::shared_ptr<MMI::AxisEvent>& axisEvent) const
+{
+    // do nothing
+    return false;
+}
+
 void PlaceHolderWindow::Create(std::string name, DisplayId displyId, Rect rect, WindowMode mode)
 {
     WLOGFD("create inner display id: %{public}" PRIu64"", displyId);
@@ -74,7 +82,8 @@ void PlaceHolderWindow::Create(std::string name, DisplayId displyId, Rect rect,
         return;
     }
     window_->AddWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
-    RegitsterWindowListener();
+    RegisterWindowListener();
+    SetInputEventConsumer();
     if (!OHOS::Rosen::SurfaceDraw::DrawImage(window_->GetSurfaceNode(), rect.width_, rect.height_,
         IMAGE_PLACE_HOLDER_PNG_PATH)) {
         WLOGE("draw surface failed");
@@ -84,29 +93,39 @@ void PlaceHolderWindow::Create(std::string name, DisplayId displyId, Rect rect,
     WLOGFD("create palce holder Window end");
 }
 
-void PlaceHolderWindow::RegitsterWindowListener()
+void PlaceHolderWindow::RegisterWindowListener()
 {
     if (window_ == nullptr) {
-        WLOGFE("Window is nullptr, regitster window listener failed.");
+        WLOGFE("Window is nullptr, register window listener failed.");
         return;
     }
-    if (listener_ == nullptr) {
-        listener_ = new (std::nothrow) PlaceholderWindowListener();
+    if (windowListener_ == nullptr) {
+        windowListener_ = new (std::nothrow) PlaceholderWindowListener();
     }
-    window_->RegisterTouchOutsideListener(listener_);
-    window_->RegisterInputEventListener(listener_);
-    window_->RegisterLifeCycleListener(listener_);
+    window_->RegisterTouchOutsideListener(windowListener_);
+    window_->RegisterLifeCycleListener(windowListener_);
 }
 
-void PlaceHolderWindow::UnRegitsterWindowListener()
+void PlaceHolderWindow::UnRegisterWindowListener()
 {
-    if (window_ == nullptr || listener_ == nullptr) {
-        WLOGFE("Window or listener is nullptr, unregitster window listener failed.");
+    if (window_ == nullptr || windowListener_ == nullptr) {
+        WLOGFE("Window or listener is nullptr, unregister window listener failed.");
         return;
     }
-    window_->UnregisterTouchOutsideListener(listener_);
-    window_->UnregisterInputEventListener(listener_);
-    window_->UnregisterLifeCycleListener(listener_);
+    window_->UnregisterTouchOutsideListener(windowListener_);
+    window_->UnregisterLifeCycleListener(windowListener_);
+}
+
+void PlaceHolderWindow::SetInputEventConsumer()
+{
+    if (window_ == nullptr) {
+        WLOGFE("Window is nullptr, set window input event consumer failed.");
+        return;
+    }
+    if (inputEventConsumer_ == nullptr) {
+        inputEventConsumer_ = std::make_shared<PlaceholderInputEventConsumer>();
+    }
+    window_->SetInputEventConsumer(inputEventConsumer_);
 }
 
 void PlaceHolderWindow::Destroy()
@@ -114,7 +133,8 @@ void PlaceHolderWindow::Destroy()
     WLOGFI("destroy place holder window begin.");
     if (window_ != nullptr) {
         WLOGFI("destroy place holder window not nullptr.");
-        UnRegitsterWindowListener();
+        UnRegisterWindowListener();
+        window_->SetInputEventConsumer(nullptr);
         window_->Destroy();
     }
     window_ = nullptr;