Merge lp:~aacid/ubuntu-ui-toolkit/LiveTimer into lp:ubuntu-ui-toolkit/staging

[Albert Astals Cid]

Added LiveTimer

Added LiveTimer

[lp:~aacid/ubuntu-ui-toolkit/LiveTimer]

1603. By Nick Dedekind on 2015-08-12

Added LiveTimer

1604. By Nick Dedekind on 2015-08-12

added test for LiveTimer

1605. By Nick Dedekind on 2015-08-12

updated api

1606. By Nick Dedekind on 2015-08-12

Document LiveTimer

1607. By Nick Dedekind on 2015-08-12

Fixed docs

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1214
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2118/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/846
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/848
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/848/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/845

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2118/rebuild

review: Approve (continuous-integration)

[Albert Astals Cid (aacid)]

It's just a re-merged https://code.launchpad.net/~nick-dedekind/ubuntu-ui-toolkit/LiveTimer/+merge/265281

[Zsombor Egri (zsombi)]

Was reviewed before, so let's land it.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1607
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2120/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/848
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/850
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/850/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/847

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2120/rebuild

review: Approve (continuous-integration)

=== modified file 'components.api'
--- components.api	2015-08-11 13:02:37 +0000
+++ components.api	2015-08-12 09:56:54 +0000
@@ -489,6 +489,16 @@
     function swipeEvent(SwipeEvent event)
     function rebound()
     property Animation snapAnimation
+Ubuntu.Components.LiveTimer 1.3: QtObject
+    property Frequency frequency
+    signal trigger()
+    property QDateTime relativeTime
+Ubuntu.Components.LiveTimer.Frequency: Enum
+    Disabled
+    Hour
+    Minute
+    Relative
+    Second
 Ubuntu.Components.MainView 1.0 0.1: MainViewBase
     property bool automaticOrientation
     default readonly property QtObject contentsItem

=== added file 'src/Ubuntu/Components/plugin/livetimer.cpp'
--- src/Ubuntu/Components/plugin/livetimer.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/livetimer.cpp	2015-08-12 09:56:54 +0000
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2015 Canonical 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "livetimer.h"
+#include "livetimer_p.h"
+
+/*! \qmltype LiveTimer
+    \instantiates LiveTimer
+    \inqmlmodule Ubuntu.Components 1.3
+    \ingroup ubuntu
+    \since Ubuntu.Components 1.3
+    \brief A live timing source providing peridioc updates.
+
+    The LiveTimer is a source for periodic signals triggered on second/minute/hour boundaries. The
+    timer can also be set up to provide signals with an increasing frequency the closer a given time
+    is to current time.
+
+    Examples:
+
+    \qml
+    import Ubuntu.Components 1.3
+
+    LiveTimer {
+        frequency: LiveTimer.Second
+        onTrigger: console.log("The time is now", new Date().toString());
+    }
+    \endqml
+
+    \qml
+    import Ubuntu.Components 1.3
+
+    LiveTimer {
+        frequency: LiveTimer.Relative
+        relativeTime: new Date()
+    }
+    \endqml
+*/
+LiveTimer::LiveTimer(QObject *parent)
+    : QObject(parent)
+    , m_frequency(Disabled)
+    , m_effectiveFrequency(Disabled)
+    , m_lastUpdate(0)
+{
+}
+
+LiveTimer::~LiveTimer()
+{
+    unregisterTimer();
+}
+
+/*!
+ * \qmlsignal LiveTimer::trigger()
+ * Signal called when the timer is triggered
+ */
+
+/*! \qmlproperty enumeration LiveTimer::frequency
+    \since Ubuntu.Components 1.3
+
+    This properties defines the frequency at which the LiveTimer signals notifications.
+
+    \list
+    \li \b LiveTimer.Disabled - disable the LiveTimer \l trigger signal
+    \li \b LiveTimer.Second - emit the \l trigger signal on every change of second.
+    \li \b LiveTimer.Minute - emit the \l trigger signal on every change of minute.
+    \li \b LiveTimer.Hour - emit the \l trigger signal on every change of hour.
+    \li \b LiveTimer.Relative - emit the \l trigger signal periodically depending on how close current time is to to
+    \l relativeTime. If \l relativeTime is within 30 seconds of the current time, trigger every 30 seconds. Within an hour,
+    trigger every minute. Otherwise, trigger every hour until the relative time is more than a week past current time, after which
+    updates are disabled.
+
+    \note Setting the frequency to LiveTimer.Relative will disable the timer until a \l relativeTime is set.
+
+    \endlist
+*/
+void LiveTimer::setFrequency(LiveTimer::Frequency frequency)
+{
+    if (m_frequency != frequency) {
+        m_frequency = frequency;
+        Q_EMIT frequencyChanged();
+
+        if (m_frequency != Disabled && (m_frequency != Relative || m_relativeTime.isValid())) {
+            registerTimer();
+        } else {
+            unregisterTimer();
+        }
+    }
+}
+
+/*! \qmlproperty datetime LiveTimer::relativeTime
+    \since Ubuntu.Components 1.3
+
+    This properties defines the value used for proximity evaluation when using Relative mode.
+
+    \note This property has no impact unless the \l frequency is set to LiveTimer.Relative
+*/
+void LiveTimer::setRelativeTime(const QDateTime &relativeTime)
+{
+    if (m_relativeTime != relativeTime) {
+        m_relativeTime = relativeTime;
+        Q_EMIT relativeTimeChanged();
+
+        if (m_frequency == Relative) {
+            if (m_relativeTime.isValid()) {
+                registerTimer();
+            } else {
+                unregisterTimer();
+            }
+        }
+    }
+}
+
+void LiveTimer::registerTimer()
+{
+    SharedLiveTimer::instance().registerTimer(this);
+
+    QObject::connect(&SharedLiveTimer::instance(), &SharedLiveTimer::trigger, this, &LiveTimer::trigger);
+}
+
+void LiveTimer::unregisterTimer()
+{
+    QObject::disconnect(&SharedLiveTimer::instance(), &SharedLiveTimer::trigger, this, 0);
+    SharedLiveTimer::instance().unregisterTimer(this);
+
+}
+
+void LiveTimer::setEffectiveFrequency(LiveTimer::Frequency frequency)
+{
+    m_effectiveFrequency = frequency;
+}

=== added file 'src/Ubuntu/Components/plugin/livetimer.h'
--- src/Ubuntu/Components/plugin/livetimer.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/livetimer.h	2015-08-12 09:56:54 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2015 Canonical 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIVETIMER_H
+#define LIVETIMER_H
+
+#include <QObject>
+#include <QDateTime>
+
+class LiveTimer : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(Frequency)
+    Q_PROPERTY(Frequency frequency READ frequency WRITE setFrequency NOTIFY frequencyChanged)
+    Q_PROPERTY(QDateTime relativeTime READ relativeTime WRITE setRelativeTime NOTIFY relativeTimeChanged)
+public:
+    explicit LiveTimer(QObject *parent = 0);
+    ~LiveTimer();
+
+    enum Frequency {
+        Disabled = 0,
+        Second = 1,
+        Minute = 2,
+        Hour = 3,
+        Relative = 4
+    };
+
+    Frequency frequency() const { return m_frequency; }
+    void setFrequency(Frequency frequency);
+
+    QDateTime relativeTime() const { return m_relativeTime; }
+    void setRelativeTime(const QDateTime& relativeTime);
+
+    Frequency effectiveFrequency() const { return m_effectiveFrequency; }
+
+Q_SIGNALS:
+    void frequencyChanged();
+    void relativeTimeChanged();
+
+    void trigger();
+
+private:
+    void registerTimer();
+    void unregisterTimer();
+    void setEffectiveFrequency(Frequency frequency);
+
+    Frequency m_frequency;
+    Frequency m_effectiveFrequency;
+    QDateTime m_relativeTime;
+    quint64 m_lastUpdate;
+
+    friend class SharedLiveTimer;
+};
+
+#endif // LIVETIMER_H

=== added file 'src/Ubuntu/Components/plugin/livetimer_p.cpp'
--- src/Ubuntu/Components/plugin/livetimer_p.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/livetimer_p.cpp	2015-08-12 09:56:54 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2015 Canonical 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "livetimer_p.h"
+#include "timeutils_p.h"
+
+#include <QDBusConnection>
+
+SharedLiveTimer::SharedLiveTimer(QObject* parent)
+    : QObject(parent)
+    , m_frequency(LiveTimer::Disabled)
+{
+    m_timer.setSingleShot(true);
+    connect(&m_timer, &QTimer::timeout, this, &SharedLiveTimer::timeout);
+
+    QDBusConnection::systemBus().connect("org.freedesktop.timedate1",
+                                         "/org/freedesktop/timedate1",
+                                         "org.freedesktop.DBus.Properties",
+                                         "PropertiesChanged",
+                                         this,
+                                         SLOT(timedate1PropertiesChanged(QString, QVariantMap, QStringList)));
+}
+
+void SharedLiveTimer::registerTimer(LiveTimer *timer)
+{
+    if (m_liveTimers.contains(timer)) {
+        unregisterTimer(timer);
+    }
+    m_liveTimers.append(timer);
+    updateFrequency();
+}
+
+void SharedLiveTimer::unregisterTimer(LiveTimer *timer)
+{
+    if (!m_liveTimers.contains(timer)) return;
+
+    m_liveTimers.removeAll(timer);
+    updateFrequency();
+}
+
+void SharedLiveTimer::updateFrequency()
+{
+    LiveTimer::Frequency newFreq = LiveTimer::Disabled;
+    if (m_liveTimers.count() == 0) {
+        newFreq = LiveTimer::Disabled;
+    } else {
+        Q_FOREACH(LiveTimer* timer, m_liveTimers) {
+            LiveTimer::Frequency freq = timer->frequency();
+            if (freq == LiveTimer::Relative) {
+                date_proximity_t proximity = getDateProximity(QDateTime::currentDateTime(), timer->relativeTime());
+                freq = frequencyForProximity(proximity);
+            }
+            timer->setEffectiveFrequency(freq);
+
+            if (freq != LiveTimer::Disabled && (newFreq == LiveTimer::Disabled || freq < newFreq)) {
+                newFreq =  freq;
+            }
+        }
+    }
+    if (newFreq != m_frequency) {
+        m_frequency = newFreq;
+        reInitTimer();
+    }
+}
+
+void SharedLiveTimer::reInitTimer()
+{
+    QDateTime now(QDateTime::currentDateTime());
+    m_nextUpdate = now;
+
+    switch(m_frequency) {
+        case LiveTimer::Second:
+            m_nextUpdate.setTime(QTime(now.time().hour(), now.time().minute(), now.time().second(), 0));
+            m_nextUpdate = m_nextUpdate.addSecs(1);
+            break;
+
+        case LiveTimer::Minute:
+            m_nextUpdate.setTime(QTime(now.time().hour(), now.time().minute(), 0, 0));
+            m_nextUpdate = m_nextUpdate.addSecs(60);
+            break;
+
+        case LiveTimer::Hour:
+            m_nextUpdate.setTime(QTime(now.time().hour(), 0, 0, 0));
+            m_nextUpdate = m_nextUpdate.addSecs(60*60);
+            break;
+
+        default:
+            m_timer.stop();
+            return;
+    }
+
+    qint64 diff = m_nextUpdate.toMSecsSinceEpoch() - now.toMSecsSinceEpoch();
+    m_timer.start(diff);
+}
+
+void SharedLiveTimer::timeout()
+{
+    QDateTime now(QDateTime::currentDateTime());
+    qint64 currentMSecsSinceEpoch = now.currentMSecsSinceEpoch();
+    qint64 earlyMs = m_nextUpdate.toMSecsSinceEpoch() - currentMSecsSinceEpoch;
+    if (earlyMs > 0) { // timer shouldn't have happened yet.
+        reInitTimer();
+        return;
+    }
+
+    bool isHourUpdate = m_lastUpdate.date() != now.date() ||
+            m_lastUpdate.time().hour() != now.time().hour();
+    bool isMinuteUpdate = isHourUpdate ||
+            m_lastUpdate.time().minute() != now.time().minute();
+    bool isSecondUpdate = isMinuteUpdate ||
+            m_lastUpdate.time().second() != now.time().second();
+
+    bool needsFrequencyUpdate = false;
+    QList<LiveTimer*> tmpTimers(m_liveTimers);
+    Q_FOREACH(LiveTimer* timer, tmpTimers) {
+
+        LiveTimer::Frequency effectiveFrequency = timer->effectiveFrequency();
+        if (effectiveFrequency == LiveTimer::Disabled) continue;
+
+        if (isHourUpdate) {
+            Q_EMIT timer->trigger();
+        } else if (isMinuteUpdate) {
+            if (effectiveFrequency >= LiveTimer::Second && effectiveFrequency <= LiveTimer::Minute) {
+                Q_EMIT timer->trigger();
+            }
+        } else if (isSecondUpdate) {
+            if (effectiveFrequency == LiveTimer::Second) {
+                Q_EMIT timer->trigger();
+            }
+        }
+
+        // re-evaluate relative timer frequency
+        if (timer->frequency() == LiveTimer::Relative) {
+            date_proximity_t newProximity = getDateProximity(now, timer->relativeTime());
+            needsFrequencyUpdate |= effectiveFrequency != frequencyForProximity(newProximity);
+        }
+    }
+
+    if (needsFrequencyUpdate) {
+        updateFrequency();
+    }
+    reInitTimer();
+    m_lastUpdate = now;
+}
+
+void SharedLiveTimer::timedate1PropertiesChanged(const QString &interface, const QVariantMap &changed, const QStringList &)
+{
+    if (interface != "org.freedesktop.timedate1") return;
+    if (!changed.contains("Timezone")) return;
+
+    QList<LiveTimer*> tmpTimers(m_liveTimers);
+    Q_FOREACH(LiveTimer* timer, tmpTimers) {
+        Q_EMIT timer->trigger();
+    }
+    reInitTimer();
+}

=== added file 'src/Ubuntu/Components/plugin/livetimer_p.h'
--- src/Ubuntu/Components/plugin/livetimer_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/livetimer_p.h	2015-08-12 09:56:54 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2015 Canonical 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIVETIMER_P_H
+#define LIVETIMER_P_H
+
+#include "livetimer.h"
+
+#include <QTimer>
+
+class SharedLiveTimer : public QObject
+{
+    Q_OBJECT
+public:
+    SharedLiveTimer(QObject* parent = NULL);
+
+    static SharedLiveTimer& instance()
+    {
+        static SharedLiveTimer instance;
+        return instance;
+    }
+
+    void registerTimer(LiveTimer* timer);
+    void unregisterTimer(LiveTimer* timer);
+
+private Q_SLOTS:
+    void timeout();
+    void timedate1PropertiesChanged(const QString &interface, const QVariantMap &changed, const QStringList&);
+
+Q_SIGNALS:
+    void trigger();
+
+private:
+    void updateFrequency();
+    void reInitTimer();
+
+    QList<LiveTimer*> m_liveTimers;
+    QTimer m_timer;
+    LiveTimer::Frequency m_frequency;
+
+    QDateTime m_nextUpdate;
+    QDateTime m_lastUpdate;
+};
+
+#endif // LIVETIMER_P_H

=== modified file 'src/Ubuntu/Components/plugin/plugin.cpp'
--- src/Ubuntu/Components/plugin/plugin.cpp	2015-08-11 13:02:37 +0000
+++ src/Ubuntu/Components/plugin/plugin.cpp	2015-08-12 09:56:54 +0000
@@ -27,6 +27,7 @@
 #include <QtQml/QQmlContext>
 #include "i18n.h"
 #include "listener.h"
+#include "livetimer.h"
 #include "ucunits.h"
 #include "ucscalingimageprovider.h"
 #include "ucqquickimageextension.h"
@@ -218,6 +219,7 @@
     qmlRegisterType<UCAction, 1>(uri, 1, 3, "Action");
     qmlRegisterType<UCUbuntuShape, 2>(uri, 1, 3, "UbuntuShape");
     qmlRegisterType<UCProportionalShape>(uri, 1, 3, "ProportionalShape");
+    qmlRegisterType<LiveTimer>(uri, 1, 3, "LiveTimer");
 }
 
 void UbuntuComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'src/Ubuntu/Components/plugin/plugin.pri'
--- src/Ubuntu/Components/plugin/plugin.pri	2015-08-11 13:02:37 +0000
+++ src/Ubuntu/Components/plugin/plugin.pri	2015-08-12 09:56:54 +0000
@@ -77,7 +77,10 @@
     $$PWD/ucnamespace.h \
     $$PWD/ucdeprecatedtheme.h \
     $$PWD/ucdefaulttheme.h \
-    $$PWD/ucstylehints.h
+    $$PWD/ucstylehints.h \
+    $$PWD/livetimer.h \
+    $$PWD/livetimer_p.h \
+    $$PWD/timeutils_p.h
 
 SOURCES += $$PWD/plugin.cpp \
     $$PWD/uctheme.cpp \
@@ -127,7 +130,9 @@
     $$PWD/ucnamespace.cpp \
     $$PWD/ucdeprecatedtheme.cpp \
     $$PWD/ucdefaulttheme.cpp \
-    $$PWD/ucstylehints.cpp
+    $$PWD/ucstylehints.cpp \
+    $$PWD/livetimer.cpp \
+    $$PWD/livetimer_p.cpp
 
 # adapters
 SOURCES += $$PWD/adapters/alarmsadapter_organizer.cpp

=== added file 'src/Ubuntu/Components/plugin/timeutils_p.h'
--- src/Ubuntu/Components/plugin/timeutils_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/timeutils_p.h	2015-08-12 09:56:54 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2014 Canonical 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; version 3.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TIMEUTILS_P_H
+#define TIMEUTILS_P_H
+
+#include "livetimer.h"
+
+#include <QDateTime>
+#include <QObject>
+#include <QTimer>
+
+typedef enum
+{
+   DATE_PROXIMITY_NOW,
+   DATE_PROXIMITY_HOUR,
+   DATE_PROXIMITY_TODAY,
+   DATE_PROXIMITY_YESTERDAY,
+   DATE_PROXIMITY_TOMORROW,
+   DATE_PROXIMITY_LAST_WEEK,
+   DATE_PROXIMITY_NEXT_WEEK,
+   DATE_PROXIMITY_FAR_BACK,
+   DATE_PROXIMITY_FAR_FORWARD
+} date_proximity_t;
+
+inline date_proximity_t getDateProximity(const QDateTime& now, const QDateTime& time)
+{
+   int now_day = now.date().day();
+   int now_month = now.date().month();
+   int now_year = now.date().year();
+
+   int time_day = time.date().day();
+   int time_month = time.date().month();
+   int time_year = time.date().year();
+
+   qint64 diff = time.toMSecsSinceEpoch() - now.toMSecsSinceEpoch();
+   if (qAbs(diff) < 30000) return DATE_PROXIMITY_NOW;
+   else if (qAbs(diff) < 3600000) return DATE_PROXIMITY_HOUR;
+
+   // does it happen today?
+   if ((now_year == time_year) && (now_month == time_month) && (now_day == time_day)) {
+       return DATE_PROXIMITY_TODAY;
+   }
+
+   // did it happen yesterday?
+   QDateTime yesterday(now.addDays(-1));
+   int yesterday_day = yesterday.date().day();
+   int yesterday_month = yesterday.date().month();
+   int yesterday_year = yesterday.date().year();
+   if ((yesterday_year == time_year) && (yesterday_month == time_month) && (yesterday_day == time_day)) {
+       return DATE_PROXIMITY_YESTERDAY;
+   }
+
+   // does it happen tomorrow?
+   QDateTime tomorrow(now.addDays(1));
+   int tomorrow_day = tomorrow.date().day();
+   int tomorrow_month = tomorrow.date().month();
+   int tomorrow_year = tomorrow.date().year();
+   if ((tomorrow_year == time_year) && (tomorrow_month == time_month) && (tomorrow_day == time_day)) {
+       return DATE_PROXIMITY_TOMORROW;
+   }
+
+   if (time < now) {
+       QDateTime lastWeek(now.addDays(-6));
+       QDateTime lastWeekBound(lastWeek.date(), QTime(0, 0, 0, 0));
+
+       // does it happen last week?
+       if (time >= lastWeekBound) {
+           return DATE_PROXIMITY_LAST_WEEK;
+       }
+       return DATE_PROXIMITY_FAR_BACK;
+   } else {
+       QDateTime nextWeek(now.addDays(6));
+       QDateTime nextWeekBound(nextWeek.date(), QTime(23, 59, 59, 999));
+
+       // does it happen this week?
+       if (time <= nextWeekBound) {
+           return DATE_PROXIMITY_NEXT_WEEK;
+       }
+       return DATE_PROXIMITY_FAR_FORWARD;
+   }
+}
+
+inline LiveTimer::Frequency frequencyForProximity(date_proximity_t proximity) {
+    switch(proximity) {
+        case DATE_PROXIMITY_NOW:
+            return LiveTimer::Second;
+        case DATE_PROXIMITY_HOUR:
+            return LiveTimer::Minute;
+        case DATE_PROXIMITY_TODAY:
+        case DATE_PROXIMITY_TOMORROW:
+        case DATE_PROXIMITY_YESTERDAY:
+        case DATE_PROXIMITY_LAST_WEEK:
+        case DATE_PROXIMITY_NEXT_WEEK:
+        case DATE_PROXIMITY_FAR_FORWARD:
+            return LiveTimer::Hour;
+        case DATE_PROXIMITY_FAR_BACK:
+        default:
+            break;
+    }
+    return LiveTimer::Disabled;
+}
+
+#endif // TIMEUTILS_P_H

=== added file 'tests/unit/tst_components/tst_livetimer.qml'
--- tests/unit/tst_components/tst_livetimer.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_components/tst_livetimer.qml	2015-08-12 09:56:54 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.Components 1.3
+
+TestCase {
+    name: "LiveTimer"
+
+    function test_0_defaults() {
+        compare(liveTimer.frequency, LiveTimer.Disabled, "Default frequency");
+    }
+
+    function test_frequency_data() {
+        return [
+            { tag:"Disabled", frequency: LiveTimer.Disabled },
+            { tag:"Second", frequency: LiveTimer.Second },
+            { tag:"Minute", frequency: LiveTimer.Minute },
+            { tag:"Hour", frequency: LiveTimer.Hour },
+            { tag:"Relative", frequency: LiveTimer.Relative },
+        ];
+    }
+
+    function test_frequency(data) {
+        liveTimer.frequency = data.frequency;
+        compare(liveTimer.frequency, data.frequency, "LiveTimer frequency can be set.");
+    }
+
+    function test_relativeTime() {
+        liveTimer.relativeTime = new Date(2015, 0, 0, 0, 0, 0, 0);
+        compare(liveTimer.relativeTime, new Date(2015, 0, 0, 0, 0, 0, 0), "Can set/get relativeTime")
+    }
+
+    LiveTimer {
+        id: liveTimer
+    }
+}