Merge lp:~boiko/telephony-service/fix_call_duration into lp:telephony-service

[Gustavo Pichorim Boiko]

Get the active timestamp for calls from the handler, as the observer is unregistered every time the application goes out of focus. This ensures that the call duration will always be correct.
Save also the DTMF string so that the application can restore that info too after it is send to background and back to foreground.

Get the active timestamp for calls from the handler, as the observer is unregistered every time the application goes out of focus. This ensures that the call duration will always be correct.
Save also the DTMF string so that the application can restore that info too after it is send to background and back to foreground.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:768
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/104/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-amd64-ci/28/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/32/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-i386-ci/28/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telephony-service-ci/104/rebuild

review: Needs Fixing (continuous-integration)

[lp:~boiko/telephony-service/fix_call_duration]

769. By Gustavo Pichorim Boiko on 2014-01-31

Merge latest changes from trunk.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:769
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/105/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-amd64-ci/29
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/33
        deb: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/33/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-i386-ci/29

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telephony-service-ci/105/rebuild

review: Approve (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

Are there any related MPs required for this MP to build/function as expected? Please list: No
Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes): Yes
Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?: Yes
Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/telephony-service) on device or emulator? Yes
If you changed the UI, was the change specified/approved by design? No UI changes.
If you changed the packaging (debian), did you subscribe a core-dev to this MP? No packaging changes.

[Bill Filler (bfiller)]

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
YES

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/<package-name>) on device or emulator?
YES

Did CI run pass? If not, please explain why.
YES

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
YES

review: Approve

=== modified file 'handler/Handler.xml'
--- handler/Handler.xml	2013-07-17 18:06:28 +0000
+++ handler/Handler.xml	2014-01-31 15:23:33 +0000
@@ -67,5 +67,22 @@
             <arg name="objectPath" type="s" direction="in"/>
             <arg name="key" type="s" direction="in"/>
         </method>
+        <method name="GetCallProperties">
+            <dox:d><![CDATA[
+                Get the properties of a given call channel
+            ]]></dox:d>
+            <arg name="objectPath" type="s" direction="in"/>
+            <arg name="properties" type="a{sv}" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+        </method>
+        <signal name="CallPropertiesChanged">
+            <dox:d><![CDATA[
+                The properties of a given call changed.
+            ]]></dox:d>
+            <arg name="objectPath" type="s"/>
+            <arg name="properties" type="a{sv}"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="QVariantMap"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
+        </signal>
     </interface>
 </node>

=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2013-11-11 14:54:50 +0000
+++ handler/callhandler.cpp	2014-01-31 15:23:33 +0000
@@ -39,6 +39,31 @@
     return self;
 }
 
+QVariantMap CallHandler::getCallProperties(const QString &objectPath)
+{
+    QVariantMap properties;
+    Tp::CallChannelPtr channel = callFromObjectPath(objectPath);
+    if (!channel) {
+        return properties;
+    }
+
+    QVariant property = channel->property("timestamp");
+    if (property.isValid()) {
+        properties["timestamp"] = property;
+    }
+
+    property = channel->property("activeTimestamp");
+    if (property.isValid()) {
+        properties["activeTimestamp"] = property;
+    }
+    property = channel->property("dtmfString");
+    if (property.isValid()) {
+        properties["dtmfString"] = property;
+    }
+
+    return properties;
+}
+
 CallHandler::CallHandler(QObject *parent)
 : QObject(parent)
 {
@@ -116,6 +141,11 @@
         return;
     }
 
+    // save the dtmfString to send to clients that request it
+    QString dtmfString = channel->property("dtmfString").toString();
+    dtmfString += key;
+    channel->setProperty("dtmfString", dtmfString);
+
     Q_FOREACH(const Tp::CallContentPtr &content, channel->contents()) {
         if (content->supportsDTMF()) {
             bool ok;
@@ -133,6 +163,8 @@
             content->startDTMFTone(event);
         }
     }
+
+    Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
 }
 
 void CallHandler::onCallChannelAvailable(Tp::CallChannelPtr channel)
@@ -145,10 +177,14 @@
     QVariantList args = reply.arguments();
     QMap<QString, QVariant> map = qdbus_cast<QMap<QString, QVariant> >(args[0]);
     channel->setProperty("hasSpeakerProperty", map.contains(PROPERTY_SPEAKERMODE));
+    channel->setProperty("timestamp", QDateTime::currentDateTimeUtc());
 
     connect(channel.data(),
             SIGNAL(invalidated(Tp::DBusProxy*,QString,QString)),
             SLOT(onCallChannelInvalidated()));
+    connect(channel.data(),
+            SIGNAL(callStateChanged(Tp::CallState)),
+            SLOT(onCallStateChanged(Tp::CallState)));
 
     mCallChannels.append(channel);
 }
@@ -198,6 +234,21 @@
     mCallChannels.removeAll(channel);
 }
 
+void CallHandler::onCallStateChanged(Tp::CallState state)
+{
+    Tp::CallChannelPtr channel(qobject_cast<Tp::CallChannel*>(sender()));
+    if (!channel) {
+        return;
+    }
+
+    switch (state) {
+    case Tp::CallStateActive:
+        channel->setProperty("activeTimestamp", QDateTime::currentDateTimeUtc());
+        Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
+        break;
+    }
+}
+
 Tp::CallChannelPtr CallHandler::existingCall(const QString &phoneNumber)
 {
     Tp::CallChannelPtr channel;

=== modified file 'handler/callhandler.h'
--- handler/callhandler.h	2013-07-18 17:02:10 +0000
+++ handler/callhandler.h	2014-01-31 15:23:33 +0000
@@ -35,6 +35,7 @@
 
 public:
     static CallHandler *instance();
+    QVariantMap getCallProperties(const QString &objectPath);
 
 public Q_SLOTS:
     void onCallChannelAvailable(Tp::CallChannelPtr channel);
@@ -45,6 +46,9 @@
     void setSpeakerMode(const QString &objectPath, bool enabled);
     void sendDTMF(const QString &objectPath, const QString &key);
 
+Q_SIGNALS:
+    void callPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
+
 protected:
     Tp::CallChannelPtr existingCall(const QString &phoneNumber);
     Tp::CallChannelPtr callFromObjectPath(const QString &objectPath);
@@ -53,6 +57,7 @@
     void onContactsAvailable(Tp::PendingOperation *op);
     void onCallHangupFinished(Tp::PendingOperation *op);
     void onCallChannelInvalidated();
+    void onCallStateChanged(Tp::CallState state);
 
 private:
     explicit CallHandler(QObject *parent = 0);

=== modified file 'handler/handlerdbus.cpp'
--- handler/handlerdbus.cpp	2013-07-18 17:02:10 +0000
+++ handler/handlerdbus.cpp	2014-01-31 15:23:33 +0000
@@ -34,12 +34,20 @@
 
 HandlerDBus::HandlerDBus(QObject* parent) : QObject(parent)
 {
+    connect(CallHandler::instance(),
+            SIGNAL(callPropertiesChanged(QString,QVariantMap)),
+            SIGNAL(CallPropertiesChanged(QString,QVariantMap)));
 }
 
 HandlerDBus::~HandlerDBus()
 {
 }
 
+QVariantMap HandlerDBus::GetCallProperties(const QString &objectPath)
+{
+    return CallHandler::instance()->getCallProperties(objectPath);
+}
+
 bool HandlerDBus::connectToBus()
 {
     bool ok = QDBusConnection::sessionBus().registerService(DBUS_SERVICE);

=== modified file 'handler/handlerdbus.h'
--- handler/handlerdbus.h	2013-07-18 17:02:10 +0000
+++ handler/handlerdbus.h	2014-01-31 15:23:33 +0000
@@ -39,6 +39,8 @@
     HandlerDBus(QObject* parent=0);
     ~HandlerDBus();
 
+    QVariantMap GetCallProperties(const QString &objectPath);
+
 public Q_SLOTS:
     bool connectToBus();
 
@@ -56,6 +58,7 @@
 
 Q_SIGNALS:
     void onMessageSent(const QString &number, const QString &message);
+    void CallPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
 };
 
 #endif // HANDLERDBUS_H

=== modified file 'handler/tests/HandlerTest.cpp'
--- handler/tests/HandlerTest.cpp	2014-01-22 19:44:38 +0000
+++ handler/tests/HandlerTest.cpp	2014-01-31 15:23:33 +0000
@@ -32,6 +32,7 @@
     void testMakingCalls();
     void testHangUpCall();
     void testCallHold();
+    void testCallProperties();
     void testSendMessage();
 
 private:
@@ -124,6 +125,61 @@
     MockController::instance()->hangupCall(callerId);
 }
 
+void HandlerTest::testCallProperties()
+{
+    QString callerId("7654321");
+
+    QVariantMap properties;
+    properties["Caller"] = callerId;
+    properties["State"] = "incoming";
+
+    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
+    QSignalSpy handlerCallPropertiesSpy(HandlerController::instance(), SIGNAL(callPropertiesChanged(QString,QVariantMap)));
+    MockController::instance()->placeCall(properties);
+
+    // wait for the channel to hit the approver
+    QTRY_COMPARE(approverCallSpy.count(), 1);
+    mApprover->acceptCall();
+
+    // wait until the call properties are changed
+    QTRY_COMPARE(handlerCallPropertiesSpy.count(), 1);
+    QString objectPath = handlerCallPropertiesSpy.first()[0].toString();
+    QVariantMap propsFromSignal = handlerCallPropertiesSpy.first()[1].toMap();
+    QVERIFY(!propsFromSignal.isEmpty());
+    QDateTime activeTimestampFromSignal;
+    QDateTime timestampFromSignal;
+    propsFromSignal["activeTimestamp"].value<QDBusArgument>() >> activeTimestampFromSignal;
+    propsFromSignal["timestamp"].value<QDBusArgument>() >> timestampFromSignal;
+    QVERIFY(activeTimestampFromSignal.isValid());
+    QVERIFY(timestampFromSignal.isValid());
+
+    // and try to get the properties using the method
+    QVariantMap propsFromMethod = HandlerController::instance()->getCallProperties(objectPath);
+    QVERIFY(!propsFromMethod.isEmpty());
+    QDateTime activeTimestampFromMethod;
+    QDateTime timestampFromMethod;
+    propsFromMethod["activeTimestamp"].value<QDBusArgument>() >> activeTimestampFromMethod;
+    propsFromMethod["timestamp"].value<QDBusArgument>() >> timestampFromMethod;
+    QCOMPARE(activeTimestampFromSignal, activeTimestampFromMethod);
+    QCOMPARE(timestampFromSignal, timestampFromMethod);
+
+    // now send some DTMF tones and check if the property is properly updated
+    handlerCallPropertiesSpy.clear();
+    QString dtmfString("1234*#");
+    for (int i = 0; i < dtmfString.length(); ++i) {
+        HandlerController::instance()->sendDTMF(objectPath, QString(dtmfString[i]));
+    }
+    QTRY_COMPARE(handlerCallPropertiesSpy.count(), dtmfString.length());
+    propsFromSignal = handlerCallPropertiesSpy.last()[1].toMap();
+    propsFromMethod = HandlerController::instance()->getCallProperties(objectPath);
+    QString dtmfStringFromSignal = propsFromSignal["dtmfString"].toString();
+    QString dtmfStringFromMethod = propsFromMethod["dtmfString"].toString();
+    QCOMPARE(dtmfStringFromSignal, dtmfString);
+    QCOMPARE(dtmfStringFromMethod, dtmfString);
+
+    HandlerController::instance()->hangUpCall(objectPath);
+}
+
 void HandlerTest::testSendMessage()
 {
     QString recipient("22222222");

=== modified file 'handler/tests/handlercontroller.cpp'
--- handler/tests/handlercontroller.cpp	2014-01-15 17:35:58 +0000
+++ handler/tests/handlercontroller.cpp	2014-01-31 15:23:33 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "handlercontroller.h"
+#include <QDBusReply>
 
 #define HANDLER_SERVICE "com.canonical.TelephonyServiceHandler"
 #define HANDLER_OBJECT "/com/canonical/TelephonyServiceHandler"
@@ -33,6 +34,20 @@
     QObject(parent),
     mHandlerInterface(HANDLER_SERVICE, HANDLER_OBJECT, HANDLER_INTERFACE)
 {
+    connect(&mHandlerInterface,
+            SIGNAL(CallPropertiesChanged(QString, QVariantMap)),
+            SIGNAL(callPropertiesChanged(QString, QVariantMap)));
+}
+
+QVariantMap HandlerController::getCallProperties(const QString &objectPath)
+{
+    QVariantMap properties;
+    QDBusReply<QVariantMap> reply = mHandlerInterface.call("GetCallProperties", objectPath);
+    if (reply.isValid()) {
+        properties = reply.value();
+    }
+
+    return properties;
 }
 
 void HandlerController::startCall(const QString &number)

=== modified file 'handler/tests/handlercontroller.h'
--- handler/tests/handlercontroller.h	2014-01-15 17:35:58 +0000
+++ handler/tests/handlercontroller.h	2014-01-31 15:23:33 +0000
@@ -29,6 +29,8 @@
 public:
     static HandlerController *instance();
 
+    QVariantMap getCallProperties(const QString &objectPath);
+
 public Q_SLOTS:
     void startCall(const QString &number);
     void hangUpCall(const QString &objectPath);
@@ -40,6 +42,9 @@
     void sendMessage(const QString &number, const QString &message);
     void acknowledgeMessages(const QString &number, const QStringList &messageIds);
 
+Q_SIGNALS:
+    void callPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
+
 private:
     explicit HandlerController(QObject *parent = 0);
     QDBusInterface mHandlerInterface;

=== modified file 'libtelephonyservice/callentry.cpp'
--- libtelephonyservice/callentry.cpp	2013-09-18 19:52:43 +0000
+++ libtelephonyservice/callentry.cpp	2014-01-31 15:23:33 +0000
@@ -23,6 +23,7 @@
 #include "callentry.h"
 #include "telepathyhelper.h"
 
+#include <QDBusReply>
 #include <QTime>
 #include <TelepathyQt/Contact>
 #include <TelepathyQt/PendingReady>
@@ -38,7 +39,6 @@
     mChannel(channel),
     mVoicemail(false),
     mLocalMuteState(false),
-    mElapsedTime(QTime::currentTime()),
     mMuteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE),
     mSpeakerInterface(channel->busName(), channel->objectPath(), CANONICAL_TELEPHONY_SPEAKER_IFACE),
     mHasSpeakerProperty(false),
@@ -46,6 +46,11 @@
 {
     setupCallChannel();
 
+    // connect to the DBus signal
+    connect(TelepathyHelper::instance()->handlerInterface(),
+            SIGNAL(CallPropertiesChanged(QString, QVariantMap)),
+            SLOT(onCallPropertiesChanged(QString,QVariantMap)));
+
     Q_EMIT incomingChanged();
 }
 
@@ -55,6 +60,14 @@
     Q_EMIT speakerChanged();
 }
 
+void CallEntry::onCallPropertiesChanged(const QString &objectPath, const QVariantMap &properties)
+{
+    if (objectPath != mChannel->objectPath()) {
+        return;
+    }
+    updateChannelProperties(properties);
+}
+
 void CallEntry::setupCallChannel()
 {
     connect(mChannel.data(),
@@ -85,6 +98,35 @@
     Q_EMIT dialingChanged();
 }
 
+void CallEntry::updateChannelProperties(const QVariantMap &properties)
+{
+    QVariantMap props = properties;
+    // fetch the properties if the map is empty
+    if (props.isEmpty()) {
+        QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
+        QDBusReply<QVariantMap> reply = phoneAppHandler->call("GetCallProperties", mChannel->objectPath());
+        if (!reply.isValid()) {
+            return;
+        }
+
+        props = reply.value();
+    }
+
+    QDateTime timestamp;
+    if (props.contains("timestamp")) {
+        props["timestamp"].value<QDBusArgument>() >> timestamp;
+    }
+    if (props.contains("activeTimestamp")) {
+        props["activeTimestamp"].value<QDBusArgument>() >> mActiveTimestamp;
+    }
+
+    mChannel->setProperty("dtmfString", props["dtmfString"]);
+    mChannel->setProperty("timestamp", timestamp);
+    mChannel->setProperty("activeTimestamp", mActiveTimestamp);
+
+    Q_EMIT dtmfStringChanged();
+}
+
 void CallEntry::timerEvent(QTimerEvent *event)
 {
     Q_EMIT elapsedTimeChanged();
@@ -140,6 +182,11 @@
     return mChannel->targetContact()->id();
 }
 
+QString CallEntry::dtmfString() const
+{
+    return mChannel->property("dtmfString").toString();
+}
+
 void CallEntry::sendDTMF(const QString &key)
 {
     QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
@@ -194,14 +241,15 @@
 
 void CallEntry::onCallStateChanged(Tp::CallState state)
 {
+    // fetch the channel properties from the handler
+    updateChannelProperties();
+
     switch (state) {
     case Tp::CallStateEnded:
         Q_EMIT callEnded();
         break;
     case Tp::CallStateActive:
-        mChannel->setProperty("activeTimestamp", QDateTime::currentDateTime());
         startTimer(1000);
-        mElapsedTime.start();
         Q_EMIT callActive();
         Q_EMIT activeChanged();
         break;
@@ -230,7 +278,10 @@
 
 int CallEntry::elapsedTime() const
 {
-    return mElapsedTime.secsTo(QTime::currentTime());
+    if (!mActiveTimestamp.isValid()) {
+        return 0;
+    }
+    return mActiveTimestamp.secsTo(QDateTime::currentDateTimeUtc());
 }
 
 bool CallEntry::isActive() const

=== modified file 'libtelephonyservice/callentry.h'
--- libtelephonyservice/callentry.h	2013-07-30 18:20:45 +0000
+++ libtelephonyservice/callentry.h	2014-01-31 15:23:33 +0000
@@ -66,6 +66,9 @@
                READ isSpeakerOn
                WRITE setSpeaker
                NOTIFY speakerChanged)
+    Q_PROPERTY(QString dtmfString
+               READ dtmfString
+               NOTIFY dtmfStringChanged)
 
 public:
     explicit CallEntry(const Tp::CallChannelPtr &channel, QObject *parent = 0);
@@ -90,6 +93,7 @@
     bool incoming() const;
     bool ringing() const;
     QString phoneNumber() const;
+    QString dtmfString() const;
 
     Q_INVOKABLE void sendDTMF(const QString &key);
     Q_INVOKABLE void endCall();
@@ -101,9 +105,11 @@
     void onCallFlagsChanged(Tp::CallFlags flags);
     void onMutedChanged(uint state);
     void onSpeakerChanged(bool active);
+    void onCallPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
 
 protected:
     void setupCallChannel();
+    void updateChannelProperties(const QVariantMap &properties = QVariantMap());
 
 Q_SIGNALS:
     void callEnded();
@@ -113,6 +119,7 @@
     void mutedChanged();
     void voicemailChanged();
     void phoneNumberChanged();
+    void dtmfStringChanged();
     void dialingChanged();
     void incomingChanged();
     void ringingChanged();
@@ -128,7 +135,7 @@
     QMap<QString, QVariant> mProperties;
     bool mVoicemail;
     bool mLocalMuteState;
-    QTime mElapsedTime;
+    QDateTime mActiveTimestamp;
     bool mHasSpeakerProperty;
     bool mSpeakerMode;
 };