Fix signal emission order for zero-duration animations

The order for non-zero-duration animations are:

* started()
* runningChanged(true)
* stopped()
* runningChanged(false)
* finished()

This patch tries to ensure that zero-duration animations have the same signal
emission order.

The problem was that when setRunning(true) was called on zero-duration
animation, it would call itself (setRunning(false)) lower in the call stack in
order to immediately stop again. This had the implication that we could emit
stopped() even before started() was emitted (since the recursive call to
setRunning(false) would actually complete before the ancestor stack frame
setRunning(true) was completed)

To fix this we emit started() *before* we call start() on the animationInstance.

There is still a bug in that runningChanged(true) is still not emitted for a
zero-duration animation, but this patch should improve the current behavior in
the sense that stopped() is not emitted _before_ started().

Task-number: QTBUG-48193
Change-Id: Ic2bc85e648e6746f6a058e2e9136515e7fdb6192
Reviewed-by: Mitch Curtis <mitch.curtis@qt.io>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
(cherry picked from commit 8e0711cafd7e78c6e5d77fdda6be91135a355cd1)
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

4 files changed, 83 insertions, 8 deletions

diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp
index 2043b50545..34942bdd9a 100644
--- a/src/quick/util/qquickanimation.cpp
+++ b/src/quick/util/qquickanimation.cpp
@@ -176,11 +176,8 @@ void QQuickAbstractAnimationPrivate::commence()
                 animationInstance = new QQuickAnimatorProxyJob(animationInstance, q);
             animationInstance->addAnimationChangeListener(this, QAbstractAnimationJob::Completion);
         }
+        emit q->started();
         animationInstance->start();
-        if (animationInstance->isStopped()) {
-            running = false;
-            emit q->stopped();
-        }
     }
 }
 
@@ -293,10 +290,8 @@ void QQuickAbstractAnimation::setRunning(bool r)
                 d->animationInstance->setLoopCount(d->animationInstance->currentLoop() + d->loopCount);
             supressStart = true;    //we want the animation to continue, rather than restart
         }
-        if (!supressStart) {
+        if (!supressStart)
             d->commence();
-            emit started();
-        }
     } else {
         if (d->paused) {
             d->paused = false; //reset paused state to false when stopped
@@ -314,7 +309,16 @@ void QQuickAbstractAnimation::setRunning(bool r)
         }
     }
 
-    emit runningChanged(d->running);
+
+    if (r == d->running) {
+        // This might happen if we start an animation with 0 duration: This will result in that
+        // commence() will emit started(), and then when it starts it will call setCurrentTime(0),
+        // (which is both start and end time of the animation), so it will also end up calling
+        // setRunning(false) (recursively) and stop the animation.
+        // Therefore, the state of d->running will in that case be different than r if we are back in
+        // the root stack frame of the recursive calls to setRunning()
+        emit runningChanged(d->running);
+    }
 }
 
 /*!
diff --git a/tests/auto/quick/qquickanimations/data/signalorder.qml b/tests/auto/quick/qquickanimations/data/signalorder.qml
new file mode 100644
index 0000000000..35029b0c84
--- /dev/null
+++ b/tests/auto/quick/qquickanimations/data/signalorder.qml
@@ -0,0 +1,27 @@
+import QtQuick 2.12
+
+
+Item {
+    id: wrapper
+    width: 400; height: 400
+
+    Rectangle {
+        id: greenRect
+        width: 50; height: 50
+        color: "red"
+
+        ColorAnimation on color {
+            id: colorAnimation
+            objectName: "ColorAnimation"
+            to: "green"
+            duration: 10
+            running: false
+        }
+
+        ParallelAnimation {
+            id: parallelAnimation
+            objectName: "ParallelAnimation"
+            running: false
+        }
+    }
+}
diff --git a/tests/auto/quick/qquickanimations/qquickanimations.pro b/tests/auto/quick/qquickanimations/qquickanimations.pro
index 1c5494a24a..fa46cb422d 100644
--- a/tests/auto/quick/qquickanimations/qquickanimations.pro
+++ b/tests/auto/quick/qquickanimations/qquickanimations.pro
@@ -64,6 +64,7 @@ OTHER_FILES += \
     data/scriptActionCrash.qml \
     data/sequentialAnimationNullChildBug.qml \
     data/signals.qml \
+    data/signalorder.qml \
     data/transitionAssignmentBug.qml \
     data/valuesource.qml \
     data/valuesource2.qml
diff --git a/tests/auto/quick/qquickanimations/tst_qquickanimations.cpp b/tests/auto/quick/qquickanimations/tst_qquickanimations.cpp
index d9b42bdeb5..e0ce2d7134 100644
--- a/tests/auto/quick/qquickanimations/tst_qquickanimations.cpp
+++ b/tests/auto/quick/qquickanimations/tst_qquickanimations.cpp
@@ -89,6 +89,8 @@ private slots:
     void easingProperties();
     void rotation();
     void startStopSignals();
+    void signalOrder_data();
+    void signalOrder();
     void runningTrueBug();
     void nonTransitionBug();
     void registrationBug();
@@ -1292,6 +1294,47 @@ void tst_qquickanimations::startStopSignals()
     QVERIFY(timer.elapsed() >= 200);
 }
 
+void tst_qquickanimations::signalOrder_data()
+{
+    QTest::addColumn<QByteArray>("animationType");
+    QTest::addColumn<int>("duration");
+
+    QTest::addRow("ColorAnimation, duration = 10") << QByteArray("ColorAnimation") << 10;
+    QTest::addRow("ColorAnimation, duration = 0") << QByteArray("ColorAnimation") << 0;
+    QTest::addRow("ParallelAnimation, duration = 0") << QByteArray("ParallelAnimation") << 0;
+}
+
+void tst_qquickanimations::signalOrder()
+{
+    QFETCH(QByteArray, animationType);
+    QFETCH(int, duration);
+
+    QQmlEngine engine;
+    QQmlComponent c(&engine, testFileUrl("signalorder.qml"));
+    QScopedPointer<QObject> obj(c.create());
+    auto *root = qobject_cast<QQuickItem *>(obj.data());
+    QVERIFY(root);
+    QQuickAbstractAnimation *animation = root->findChild<QQuickAbstractAnimation*>(animationType);
+    QVector<const char*> actualSignalOrder;
+    connect(animation, &QQuickAbstractAnimation::started , [&actualSignalOrder] () {
+        actualSignalOrder.append("started");
+    });
+    connect(animation, &QQuickAbstractAnimation::stopped , [&actualSignalOrder] () {
+        actualSignalOrder.append("stopped");
+    });
+    connect(animation, &QQuickAbstractAnimation::finished , [&actualSignalOrder] () {
+        actualSignalOrder.append("finished");
+    });
+    QSignalSpy finishedSpy(animation, SIGNAL(finished()));
+    if (QQuickColorAnimation *colorAnimation = qobject_cast<QQuickColorAnimation*>(animation))
+        colorAnimation->setDuration(duration);
+
+    animation->start();
+    QTRY_VERIFY(finishedSpy.count());
+    const QVector<const char*> expectedSignalOrder = { "started", "stopped", "finished" };
+    QCOMPARE(actualSignalOrder, expectedSignalOrder);
+}
+
 void tst_qquickanimations::runningTrueBug()
 {
     //ensure we start correctly when "running: true" is explicitly set