qml: update block clock at minute resolution

Author: johnny9

qml/models/blockclockmodel.cpp

@@ -12,18 +12,28 @@
 
 #include <QTime>
 
-BlockClockModel::BlockClockModel(HistoryLoader history_loader, bool start_timer, QObject* parent)
+BlockClockModel::BlockClockModel(HistoryLoader history_loader, bool start_timer,
+                                 CurrentTimeProvider current_time_provider, QObject* parent)
     : QObject{parent},
       m_history_loader{std::move(history_loader)},
+      m_current_time_provider{std::move(current_time_provider)},
       m_clock_timer{this}
 {
-    m_clock_timer.setInterval(1000);
+    if (!m_current_time_provider) {
+        m_current_time_provider = [] { return QDateTime::currentDateTime(); };
+    }
+
+    m_clock_timer.setSingleShot(true);
+    m_clock_timer.setTimerType(Qt::PreciseTimer);
     connect(&m_clock_timer, &QTimer::timeout, this, [this] {
-        updateCurrentTime(QDateTime::currentDateTime());
+        const QDateTime current_time{m_current_time_provider()};
+        updateCurrentTime(current_time);
+        scheduleNextClockUpdate(current_time);
     });
 
-    updateCurrentTime(QDateTime::currentDateTime());
-    if (start_timer) m_clock_timer.start();
+    const QDateTime current_time{m_current_time_provider()};
+    updateCurrentTime(current_time);
+    if (start_timer) scheduleNextClockUpdate(current_time);
 }
 
 qint64 BlockClockModel::PeriodStartFor(const QDateTime& current_time)
@@ -53,6 +63,13 @@ void BlockClockModel::updateCurrentTime(const QDateTime& current_time)
     }
 }
 
+void BlockClockModel::scheduleNextClockUpdate(const QDateTime& current_time)
+{
+    const QTime time{current_time.time()};
+    const int milliseconds_into_minute{time.second() * 1000 + time.msec()};
+    m_clock_timer.start(CLOCK_UPDATE_INTERVAL_MS - milliseconds_into_minute);
+}
+
 void BlockClockModel::initializeHistory()
 {
     m_history_initialized = true;
@@ -61,6 +78,8 @@ void BlockClockModel::initializeHistory()
 
 void BlockClockModel::recordBlockTime(qint64 block_timestamp)
 {
+    updateCurrentTime(m_current_time_provider());
+
     const qint64 period_end{m_timeline.period_start + PERIOD_SECONDS};
     if (block_timestamp < m_timeline.period_start || block_timestamp >= period_end) return;
 

qml/models/blockclockmodel.h

@@ -32,13 +32,14 @@ struct BlockClockTimeline
 /**
  * Maintains block-clock time and history independently of its presentation.
  *
- * This model remains current while the dial is hidden. The once-per-second
- * currentTimeFraction signal is separate from blockTimeFractions so a clock
- * tick never republishes the full block history. Fractions are normalized to
- * the current twelve-hour period and are always in the range [0, 1]. An empty
- * blockTimeFractions list is valid: it means the active chain contains no
- * blocks timestamped in the displayed period, not that synchronization is
- * incomplete. Initial-sync state belongs to NodeModel.
+ * This model remains current while the dial is hidden. currentTimeFraction is
+ * refreshed at minute boundaries and when a block arrives. It is separate
+ * from blockTimeFractions so a clock tick never republishes the full block
+ * history. Fractions are normalized to the current twelve-hour period and are
+ * always in the range [0, 1]. An empty blockTimeFractions list is valid: it
+ * means the active chain contains no blocks timestamped in the displayed
+ * period, not that synchronization is incomplete. Initial-sync state belongs
+ * to NodeModel.
  *
  * All methods and the owned timer run on this object's thread (the GUI thread
  * in production). History loading is infrequent: once after node
@@ -53,9 +54,12 @@ class BlockClockModel : public QObject
 
 public:
     static constexpr qint64 PERIOD_SECONDS{12 * 60 * 60};
+    static constexpr int CLOCK_UPDATE_INTERVAL_MS{60 * 1000};
     using HistoryLoader = std::function<QList<qint64>(qint64 period_start, qint64 period_end)>;
+    using CurrentTimeProvider = std::function<QDateTime()>;
 
-    explicit BlockClockModel(HistoryLoader history_loader = {}, bool start_timer = true, QObject* parent = nullptr);
+    explicit BlockClockModel(HistoryLoader history_loader = {}, bool start_timer = true,
+                             CurrentTimeProvider current_time_provider = {}, QObject* parent = nullptr);
 
     qint64 periodStart() const { return m_timeline.period_start; }
     qreal currentTimeFraction() const { return m_current_time_fraction; }
@@ -81,12 +85,14 @@ public Q_SLOTS:
     void blockTimeFractionsChanged();
 
 private:
+    void scheduleNextClockUpdate(const QDateTime& current_time);
     void loadHistory();
     void replaceBlockHistory(QList<qint64> block_timestamps);
     void rebuildBlockTimeFractions();
     qreal fractionForTimestamp(qint64 timestamp) const;
 
     HistoryLoader m_history_loader;
+    CurrentTimeProvider m_current_time_provider;
     QTimer m_clock_timer;
     BlockClockTimeline m_timeline;
     qreal m_current_time_fraction{0.0};

test/test_blockclockmodel.cpp

@@ -23,10 +23,12 @@ class BlockClockModelTests : public QObject
 private Q_SLOTS:
     void currentTimeUsesNamedTwelveHourFraction();
     void unchangedSecondDoesNotRepublishCurrentTime();
+    void blockArrivalRefreshesCurrentTime();
     void blockHistoryIsSortedUniqueAndPeriodBounded();
     void historyLoadsOnInitializationAndPeriodRollover();
     void emptyHistoryDoesNotEmitRedundantChanges();
     void timerHasModelOwnershipAndCanBeDisabledForTests();
+    void timerAlignsToNextMinute();
 };
 
 void BlockClockModelTests::currentTimeUsesNamedTwelveHourFraction()
@@ -51,9 +53,26 @@ void BlockClockModelTests::unchangedSecondDoesNotRepublishCurrentTime()
     QCOMPARE(current_time_spy.count(), 1);
 }
 
+void BlockClockModelTests::blockArrivalRefreshesCurrentTime()
+{
+    QDateTime current_time{UtcTime(15)};
+    BlockClockModel model{{}, false, [&] { return current_time; }};
+    QSignalSpy current_time_spy{&model, &BlockClockModel::currentTimeFractionChanged};
+
+    current_time = UtcTime(15, 1);
+    model.recordBlockTime(UtcTime(15, 0, 30).toSecsSinceEpoch());
+
+    QCOMPARE(current_time_spy.count(), 1);
+    QVERIFY(qAbs(model.currentTimeFraction() - (181.0 / 720.0)) < 0.000001);
+    QCOMPARE(model.blockTimeFractions().size(), 1);
+    QVERIFY(qAbs(model.blockTimeFractions().constFirst() -
+                 (10830.0 / BlockClockModel::PERIOD_SECONDS)) < 0.000001);
+}
+
 void BlockClockModelTests::blockHistoryIsSortedUniqueAndPeriodBounded()
 {
-    BlockClockModel model{{}, false};
+    const QDateTime current_time{UtcTime(15)};
+    BlockClockModel model{{}, false, [current_time] { return current_time; }};
     model.updateCurrentTime(UtcTime(15));
     const qint64 start{model.periodStart()};
     QSignalSpy history_spy{&model, &BlockClockModel::blockTimeFractionsChanged};
@@ -106,15 +125,27 @@ void BlockClockModelTests::emptyHistoryDoesNotEmitRedundantChanges()
 
 void BlockClockModelTests::timerHasModelOwnershipAndCanBeDisabledForTests()
 {
-    BlockClockModel stopped_model{{}, false};
+    const QDateTime current_time{UtcTime(15)};
+    const auto current_time_provider{[current_time] { return current_time; }};
+    BlockClockModel stopped_model{{}, false, current_time_provider};
     QCOMPARE(stopped_model.timerActive(), false);
     QCOMPARE(stopped_model.findChildren<QTimer*>().size(), 1);
     QCOMPARE(stopped_model.findChildren<QTimer*>().constFirst()->parent(), &stopped_model);
 
-    BlockClockModel running_model{{}, true};
+    BlockClockModel running_model{{}, true, current_time_provider};
     QCOMPARE(running_model.timerActive(), true);
 }
 
+void BlockClockModelTests::timerAlignsToNextMinute()
+{
+    const QDateTime current_time{UtcTime(15, 0, 45).addMSecs(250)};
+    BlockClockModel model{{}, true, [current_time] { return current_time; }};
+    QTimer* timer{model.findChildren<QTimer*>().constFirst()};
+
+    QCOMPARE(timer->timerType(), Qt::PreciseTimer);
+    QCOMPARE(timer->interval(), BlockClockModel::CLOCK_UPDATE_INTERVAL_MS - 45250);
+}
+
 #ifdef BITCOINQML_NO_TEST_MAIN
 BITCOINQML_REGISTER_QT_TEST(BlockClockModelTests)
 #else