添加动画状态类，视图模块做相应修改

kylin-virtual-keyboard.pro

@@ -32,6 +32,7 @@ SOURCES += \
     src/virtualkeyboard/virtualkeyboardmanager.cpp \
     src/virtualkeyboard/virtualkeyboardmodel.cpp \
     src/virtualkeyboard/virtualkeyboardview.cpp \
+    src/virtualkeyboard/virtualkeyboardviewstate.cpp \
     src/virtualkeyboardentry/floatbutton.cpp \
     src/virtualkeyboardentry/floatbuttonmanager.cpp \
     src/virtualkeyboardentry/virtualkeyboardentrymanager.cpp \

src/virtualkeyboard/virtualkeyboardview.cpp

@@ -20,12 +20,23 @@
 #include <QQmlContext>
 #include <QQuickItem>
 
+#include "screenmanager.h"
+
 VirtualKeyboardView::VirtualKeyboardView(
     QObject &manager, QObject &model,
     std::shared_ptr<GeometryManager> geometryManager)
     : manager_(manager), model_(model), geometryManager_(geometryManager) {}
 
-VirtualKeyboardView::~VirtualKeyboardView() { destroyView(); }
+VirtualKeyboardView::~VirtualKeyboardView() {
+    destroyView();
+
+    currentState_.reset();
+    visibleState_.reset();
+    hidingState_.reset();
+    showingState_.reset();
+    invisibleState_.reset();
+    flippingState_.reset();
+}
 
 QRect VirtualKeyboardView::geometry() const { return view_->geometry(); }
 
@@ -60,6 +71,14 @@ void VirtualKeyboardView::flip(
     updateGeometry();
 }
 
+void VirtualKeyboardView::updateExpansionFlippingStartGeometry() {
+    auto geometry = floatGeometryManager_->geometry();
+    view_->setGeometry(geometry.x(), view_->y(), geometry.width(),
+                       geometry.height());
+
+    emitContentGeometrySignals();
+}
+
 void VirtualKeyboardView::move(int x, int y) {
     view_->setX(x);
     view_->setY(y);
@@ -81,6 +100,18 @@ void VirtualKeyboardView::initView() {
     view_->setGeometry(geometryManager_->geometry());
 }
 
+QRect VirtualKeyboardView::calculateInitialGeometry() {
+    int normalizedY =
+        std::min(getScreenHeight(), geometry().y() + geometry().height());
+
+    return QRect(geometry().x(), normalizedY, geometry().width(),
+                 geometry().height());
+}
+
+int VirtualKeyboardView::getScreenHeight() {
+    return ScreenManager::getPrimaryScreenSize().height();
+}
+
 void VirtualKeyboardView::connectSignals() {
     auto *rootObject = view_->rootObject();
 

src/virtualkeyboard/virtualkeyboardview.h

@@ -24,7 +24,11 @@
 #include <QQuickView>
 #include <QString>
 
+#include "animation/animator.h"
+#include "geometrymanager/expansiongeometrymanager.h"
+#include "geometrymanager/floatgeometrymanager.h"
 #include "geometrymanager/geometrymanager.h"
+#include "virtualkeyboard/placementmodemanager.h"
 
 class VirtualKeyboardView : public QObject {
     Q_OBJECT
@@ -49,6 +53,11 @@ public:
     void hide();
     void flip(std::shared_ptr<GeometryManager> newGeometryManager);
 
+    bool isFloatMode() const { return placementModeManager_->isFloatMode(); }
+
+    void updateExpansionFlippingStartGeometry();
+    void setAnimator(std::shared_ptr<Animator> animator);
+
 signals:
     void contentHeightChanged();
     void contentWidthChanged();
@@ -58,22 +67,56 @@ signals:
                              int globalCursorIndex);
     void imDeactivated();
 
+    void raiseAppRequested();
+    void fallAppRequested();
+
 public slots:
     void move(int x, int y);
 
 private:
+    class State;
+    class VisibleState;
+    class HidingState;
+    class ShowingState;
+    class InvisibleState;
+    class FlippingState;
+
+private:
+    void initState();
+    QRect calculateInitialGeometry();
+    static int getScreenHeight();
     void initView();
     void connectSignals();
     void destroyView();
     int getContentHeight();
     int getContentWidth();
 
+    void updateCurrentState(std::shared_ptr<State> newState);
+    void enterVisibleState();
+    void enterHidingState();
+    void enterShowingState();
+    void enterInvisibleState();
+    void enterFlippingState();
+
 private:
     QObject &manager_;
     QObject &model_;
     std::unique_ptr<QQuickView> view_ = nullptr;
+    std::unique_ptr<PlacementModeManager> placementModeManager_ = nullptr;
 
+    std::shared_ptr<Animator> animator_ = nullptr;
+
+    std::shared_ptr<State> currentState_ = nullptr;
+    std::shared_ptr<VisibleState> visibleState_ = nullptr;
+    std::shared_ptr<HidingState> hidingState_ = nullptr;
+    std::shared_ptr<ShowingState> showingState_ = nullptr;
+    std::shared_ptr<InvisibleState> invisibleState_ = nullptr;
+    std::shared_ptr<FlippingState> flippingState_ = nullptr;
+
+    std::unique_ptr<ExpansionGeometryManager> expansionGeometryManager_ =
+        nullptr;
     std::shared_ptr<GeometryManager> geometryManager_ = nullptr;
+    std::unique_ptr<FloatGeometryManager> floatGeometryManager_ = nullptr;
 };
 
 #endif // VIRTUALKEYBOARDVIEW_H

src/virtualkeyboard/virtualkeyboardviewstate.cpp

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2023 KylinSoft Co., Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "virtualkeyboard/virtualkeyboardview.h"
+#include "virtualkeyboardsettings/virtualkeyboardsettings.h"
+
+class VirtualKeyboardView::State {
+public:
+    virtual ~State() = default;
+
+    virtual bool isVirtualKeyboardVisible() = 0;
+
+    virtual void show() = 0;
+    virtual void hide() = 0;
+    virtual void flip() = 0;
+
+    virtual void onAnimationFinished() = 0;
+
+protected:
+    explicit State(VirtualKeyboardView &virtualKeyboardView)
+        : virtualKeyboardView_(virtualKeyboardView) {}
+
+protected:
+    VirtualKeyboardView &virtualKeyboardView_;
+};
+
+class VirtualKeyboardView::VisibleState : public VirtualKeyboardView::State {
+public:
+    explicit VisibleState(VirtualKeyboardView &virtualKeyboardView)
+        : State(virtualKeyboardView) {}
+    ~VisibleState() override = default;
+
+    bool isVirtualKeyboardVisible() override { return true; }
+
+    void show() override {}
+    void hide() override { virtualKeyboardView_.enterHidingState(); }
+    void flip() override { virtualKeyboardView_.enterFlippingState(); }
+
+    void onAnimationFinished() override {}
+};
+
+class VirtualKeyboardView::HidingState : public VirtualKeyboardView::State {
+public:
+    HidingState(VirtualKeyboardView &virtualKeyboardView)
+        : State(virtualKeyboardView) {}
+    ~HidingState() override = default;
+
+    bool isVirtualKeyboardVisible() override { return false; }
+
+    void show() override { virtualKeyboardView_.enterShowingState(); }
+    void hide() override {}
+    void flip() override {}
+
+    void onAnimationFinished() override {
+        virtualKeyboardView_.enterInvisibleState();
+    }
+};
+
+class VirtualKeyboardView::ShowingState : public VirtualKeyboardView::State {
+public:
+    ShowingState(VirtualKeyboardView &virtualKeyboardView)
+        : State(virtualKeyboardView) {}
+    ~ShowingState() override = default;
+
+    bool isVirtualKeyboardVisible() override { return true; }
+
+    void show() override {}
+    void hide() override { virtualKeyboardView_.enterHidingState(); }
+    void flip() override {}
+
+    void onAnimationFinished() override {
+        virtualKeyboardView_.enterVisibleState();
+    }
+};
+
+class VirtualKeyboardView::InvisibleState : public VirtualKeyboardView::State {
+public:
+    InvisibleState(VirtualKeyboardView &virtualKeyboardView)
+        : State(virtualKeyboardView) {}
+    ~InvisibleState() override = default;
+
+    bool isVirtualKeyboardVisible() override { return false; }
+
+    void show() override {
+        virtualKeyboardView_.initView();
+
+        virtualKeyboardView_.enterShowingState();
+    }
+    void hide() override {}
+    void flip() override {}
+
+    void onAnimationFinished() override {}
+};
+
+class VirtualKeyboardView::FlippingState : public VirtualKeyboardView::State {
+public:
+    FlippingState(VirtualKeyboardView &virtualKeyboardView)
+        : State(virtualKeyboardView) {}
+    ~FlippingState() override = default;
+
+    bool isVirtualKeyboardVisible() override { return true; }
+
+    void show() override {}
+    void hide() override { virtualKeyboardView_.enterInvisibleState(); }
+    void flip() override{};
+
+    void onAnimationFinished() override {
+        if (!virtualKeyboardView_.isFloatMode()) {
+            virtualKeyboardView_.updateGeometry();
+        }
+
+        virtualKeyboardView_.enterVisibleState();
+    }
+};
+
+void VirtualKeyboardView::initState() {
+    visibleState_ = std::make_shared<VisibleState>(*this);
+    hidingState_ = std::make_shared<HidingState>(*this);
+    showingState_ = std::make_shared<ShowingState>(*this);
+    invisibleState_ = std::make_shared<InvisibleState>(*this);
+    flippingState_ = std::make_shared<FlippingState>(*this);
+
+    updateCurrentState(invisibleState_);
+}
+
+void VirtualKeyboardView::setAnimator(std::shared_ptr<Animator> animator) {
+    animator_ = animator;
+    connect(animator_.get(), &Animator::animationFinished, this,
+            [this]() { currentState_->onAnimationFinished(); });
+}
+
+void VirtualKeyboardView::updateCurrentState(std::shared_ptr<State> newState) {
+    currentState_ = newState;
+}
+
+void VirtualKeyboardView::enterVisibleState() {
+    updateCurrentState(visibleState_);
+
+    if (!isFloatMode()) {
+        emit raiseAppRequested();
+    }
+}
+
+void VirtualKeyboardView::enterHidingState() {
+    updateCurrentState(hidingState_);
+
+    animator_->playHideAnimation(view_.get(), calculateInitialGeometry());
+}
+
+void VirtualKeyboardView::enterShowingState() {
+    updateCurrentState(showingState_);
+
+    animator_->playShowAnimation(view_.get(), geometry());
+}
+
+void VirtualKeyboardView::enterInvisibleState() {
+    updateCurrentState(invisibleState_);
+
+    destroyView();
+}
+
+void VirtualKeyboardView::enterFlippingState() {
+    updateCurrentState(flippingState_);
+
+    placementModeManager_->flipPlacementMode();
+
+    if (isFloatMode()) {
+        updateExpansionFlippingStartGeometry();
+
+        emit fallAppRequested();
+    }
+
+    animator_->playFlipAnimation(view_.get(), geometry());
+}