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

[Gustavo Pichorim Boiko]

Add the callIndicatorVisible property to callManager so that dialer-app can control the active call indicator visibility.

Add the callIndicatorVisible property to callManager so that dialer-app can control the active call indicator visibility.

== Checklist ==
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?
N/A

If you changed the packaging (debian), did you subscribe a core-dev to this MP?
N/A

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:820
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/216/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-utopic-amd64-ci/32
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-utopic-armhf-ci/32
        deb: http://jenkins.qa.ubuntu.com/job/telephony-service-utopic-armhf-ci/32/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-utopic-i386-ci/32

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

review: Approve (continuous-integration)

[Tiago Salem Herrmann (tiagosh)]

Looks good.

----

Did you perform an exploratory manual test run of the code change and any related functionality 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	2014-04-25 20:47:01 +0000
+++ handler/Handler.xml	2014-06-18 13:32:24 +0000
@@ -124,5 +124,13 @@
             <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="QVariantMap"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
         </signal>
+        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="true"/>
+        <property name="CallIndicatorVisible" type="b" access="readwrite"/>
+        <signal name="CallIndicatorVisibleChanged">
+            <dox:d><![CDATA[
+                The call indicator visibility has changed
+            ]]></dox:d>
+            <arg name="visible" type="b"/>
+        </signal>
     </interface>
 </node>

=== modified file 'handler/handlerdbus.cpp'
--- handler/handlerdbus.cpp	2014-04-25 20:47:01 +0000
+++ handler/handlerdbus.cpp	2014-06-18 13:32:24 +0000
@@ -33,7 +33,7 @@
 static const char* DBUS_SERVICE = "com.canonical.TelephonyServiceHandler";
 static const char* DBUS_OBJECT_PATH = "/com/canonical/TelephonyServiceHandler";
 
-HandlerDBus::HandlerDBus(QObject* parent) : QObject(parent)
+HandlerDBus::HandlerDBus(QObject* parent) : QObject(parent), mCallIndicatorVisible(false)
 {
     connect(CallHandler::instance(),
             SIGNAL(callPropertiesChanged(QString,QVariantMap)),
@@ -64,6 +64,17 @@
     return TelepathyHelper::instance()->connected();
 }
 
+bool HandlerDBus::callIndicatorVisible() const
+{
+    return mCallIndicatorVisible;
+}
+
+void HandlerDBus::setCallIndicatorVisible(bool visible)
+{
+    mCallIndicatorVisible = visible;
+    Q_EMIT CallIndicatorVisibleChanged(visible);
+}
+
 bool HandlerDBus::connectToBus()
 {
     bool ok = QDBusConnection::sessionBus().registerService(DBUS_SERVICE);

=== modified file 'handler/handlerdbus.h'
--- handler/handlerdbus.h	2014-04-25 20:47:01 +0000
+++ handler/handlerdbus.h	2014-06-18 13:32:24 +0000
@@ -34,6 +34,10 @@
 class HandlerDBus : public QObject, protected QDBusContext
 {
     Q_OBJECT
+    Q_PROPERTY(bool CallIndicatorVisible
+               READ callIndicatorVisible
+               WRITE setCallIndicatorVisible
+               NOTIFY CallIndicatorVisibleChanged)
 
 public:
     HandlerDBus(QObject* parent=0);
@@ -43,6 +47,8 @@
     bool HasCalls();
     QStringList AccountIds();
     bool IsConnected();
+    bool callIndicatorVisible() const;
+    void setCallIndicatorVisible(bool visible);
 
 public Q_SLOTS:
     bool connectToBus();
@@ -67,6 +73,10 @@
 Q_SIGNALS:
     void onMessageSent(const QString &number, const QString &message);
     void CallPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
+    void CallIndicatorVisibleChanged(bool visible);
+
+private:
+    bool mCallIndicatorVisible;
 };
 
 #endif // HANDLERDBUS_H

=== modified file 'handler/tests/HandlerTest.cpp'
--- handler/tests/HandlerTest.cpp	2014-04-09 16:46:29 +0000
+++ handler/tests/HandlerTest.cpp	2014-06-18 13:32:24 +0000
@@ -35,6 +35,7 @@
     void testCallProperties();
     void testConferenceCall();
     void testSendMessage();
+    void testActiveCallIndicator();
 
 private:
     void waitForCallActive(const QString &callerId);
@@ -258,6 +259,26 @@
     QCOMPARE(messageProperties["Recipients"].value<QStringList>().first(), recipient);
 }
 
+void HandlerTest::testActiveCallIndicator()
+{
+    // start by making sure the property is false by default
+    QVERIFY(!HandlerController::instance()->callIndicatorVisible());
+    QSignalSpy spy(HandlerController::instance(), SIGNAL(callIndicatorVisibleChanged(bool)));
+
+    // set the property to true
+    HandlerController::instance()->setCallIndicatorVisible(true);
+    QTRY_COMPARE(spy.count(), 1);
+    QVERIFY(spy.first().first().toBool());
+    QVERIFY(HandlerController::instance()->callIndicatorVisible());
+
+    // and back to false
+    spy.clear();
+    HandlerController::instance()->setCallIndicatorVisible(false);
+    QTRY_COMPARE(spy.count(), 1);
+    QVERIFY(!spy.first().first().toBool());
+    QVERIFY(!HandlerController::instance()->callIndicatorVisible());
+}
+
 void HandlerTest::waitForCallActive(const QString &callerId)
 {
     // wait until the call state is "accepted"

=== modified file 'handler/tests/handlercontroller.cpp'
--- handler/tests/handlercontroller.cpp	2014-03-20 21:03:26 +0000
+++ handler/tests/handlercontroller.cpp	2014-06-18 13:32:24 +0000
@@ -20,6 +20,7 @@
 #include <QStringList>
 #include "handlercontroller.h"
 #include <QDBusReply>
+#include <QDebug>
 
 #define HANDLER_SERVICE "com.canonical.TelephonyServiceHandler"
 #define HANDLER_OBJECT "/com/canonical/TelephonyServiceHandler"
@@ -38,6 +39,9 @@
     connect(&mHandlerInterface,
             SIGNAL(CallPropertiesChanged(QString, QVariantMap)),
             SIGNAL(callPropertiesChanged(QString, QVariantMap)));
+    connect(&mHandlerInterface,
+            SIGNAL(CallIndicatorVisibleChanged(bool)),
+            SIGNAL(callIndicatorVisibleChanged(bool)));
 }
 
 QVariantMap HandlerController::getCallProperties(const QString &objectPath)
@@ -51,6 +55,20 @@
     return properties;
 }
 
+bool HandlerController::callIndicatorVisible()
+{
+    QDBusInterface handlerPropertiesInterface("com.canonical.TelephonyServiceHandler",
+                                              "/com/canonical/TelephonyServiceHandler",
+                                              "org.freedesktop.DBus.Properties");
+    QDBusReply<QVariantMap> reply = handlerPropertiesInterface.call("GetAll", "com.canonical.TelephonyServiceHandler");
+    if (!reply.isValid()) {
+        return false;
+    }
+
+    QVariantMap map = reply.value();
+    return map["CallIndicatorVisible"].toBool();
+}
+
 void HandlerController::startCall(const QString &number, const QString &accountId)
 {
     mHandlerInterface.call("StartCall", number, accountId);
@@ -105,3 +123,13 @@
 {
     mHandlerInterface.call("AcknowledgeMessages", number, messageIds, accountId);
 }
+
+void HandlerController::setCallIndicatorVisible(bool visible)
+{
+    QDBusInterface handlerPropertiesInterface("com.canonical.TelephonyServiceHandler",
+                                              "/com/canonical/TelephonyServiceHandler",
+                                              "org.freedesktop.DBus.Properties");
+    handlerPropertiesInterface.call("Set",
+                                    "com.canonical.TelephonyServiceHandler",
+                                    "CallIndicatorVisible", QVariant::fromValue(QDBusVariant(visible)));
+}

=== modified file 'handler/tests/handlercontroller.h'
--- handler/tests/handlercontroller.h	2014-03-20 21:03:26 +0000
+++ handler/tests/handlercontroller.h	2014-06-18 13:32:24 +0000
@@ -30,6 +30,7 @@
     static HandlerController *instance();
 
     QVariantMap getCallProperties(const QString &objectPath);
+    bool callIndicatorVisible();
 
 public Q_SLOTS:
     // call methods
@@ -49,8 +50,12 @@
     void sendMessage(const QString &number, const QString &message, const QString &accountId);
     void acknowledgeMessages(const QString &number, const QStringList &messageIds, const QString &accountId);
 
+    // active call indicator
+    void setCallIndicatorVisible(bool visible);
+
 Q_SIGNALS:
     void callPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
+    void callIndicatorVisibleChanged(bool visible);
 
 private:
     explicit HandlerController(QObject *parent = 0);

=== modified file 'libtelephonyservice/callmanager.cpp'
--- libtelephonyservice/callmanager.cpp	2014-06-04 21:10:36 +0000
+++ libtelephonyservice/callmanager.cpp	2014-06-18 13:32:24 +0000
@@ -44,6 +44,46 @@
     connect(TelepathyHelper::instance(), SIGNAL(connectedChanged()), SLOT(onConnectedChanged()));
     connect(TelepathyHelper::instance(), SIGNAL(channelObserverUnregistered()), SLOT(onChannelObserverUnregistered()));
     connect(this, SIGNAL(hasCallsChanged()), SIGNAL(callsChanged()));
+    connect(this, &CallManager::hasCallsChanged, [this] {
+        Q_EMIT this->callIndicatorVisibleChanged(this->callIndicatorVisible());
+    });
+
+    refreshProperties();
+
+    // connect the dbus signal
+    QDBusConnection connection = QDBusConnection::sessionBus();
+    connection.connect("com.canonical.TelephonyServiceHandler",
+                       "/com/canonical/TelephonyServiceHandler",
+                       "com.canonical.TelephonyServiceHandler",
+                       "CallIndicatorVisibleChanged",
+                       this, SLOT(onCallIndicatorVisibleChanged(bool)));
+}
+
+void CallManager::refreshProperties()
+{
+    QDBusInterface handlerPropertiesInterface("com.canonical.TelephonyServiceHandler",
+                                              "/com/canonical/TelephonyServiceHandler",
+                                              "org.freedesktop.DBus.Properties");
+    QDBusReply<QVariantMap> reply = handlerPropertiesInterface.call("GetAll",
+                                                                    "com.canonical.TelephonyServiceHandler");
+    if (!reply.isValid()) {
+        qWarning() << "Failed to refresh the properties from the handler";
+        return;
+    }
+
+    QVariantMap map = reply.value();
+    mCallIndicatorVisible = map["CallIndicatorVisible"].toBool();
+    Q_EMIT callIndicatorVisibleChanged(mCallIndicatorVisible);
+}
+
+void CallManager::setDBusProperty(const QString &name, const QVariant &value)
+{
+    QDBusInterface handlerPropertiesInterface("com.canonical.TelephonyServiceHandler",
+                                              "/com/canonical/TelephonyServiceHandler",
+                                              "org.freedesktop.DBus.Properties");
+    handlerPropertiesInterface.call("Set",
+                                    "com.canonical.TelephonyServiceHandler",
+                                    name, QVariant::fromValue(QDBusVariant(value)));
 }
 
 QList<CallEntry *> CallManager::takeCalls(const QList<Tp::ChannelPtr> callChannels)
@@ -85,6 +125,16 @@
     Q_EMIT backgroundCallChanged();
 }
 
+bool CallManager::callIndicatorVisible() const
+{
+    return hasCalls() && mCallIndicatorVisible;
+}
+
+void CallManager::setCallIndicatorVisible(bool visible)
+{
+    setDBusProperty("CallIndicatorVisible", visible);
+}
+
 void CallManager::setupCallEntry(CallEntry *entry)
 {
     connect(entry,
@@ -150,6 +200,12 @@
     }
 }
 
+void CallManager::onCallIndicatorVisibleChanged(bool visible)
+{
+    mCallIndicatorVisible = visible;
+    Q_EMIT callIndicatorVisibleChanged(visible);
+}
+
 CallEntry *CallManager::foregroundCall() const
 {
     CallEntry *call = 0;

=== modified file 'libtelephonyservice/callmanager.h'
--- libtelephonyservice/callmanager.h	2014-03-31 19:01:42 +0000
+++ libtelephonyservice/callmanager.h	2014-06-18 13:32:24 +0000
@@ -53,6 +53,10 @@
     Q_PROPERTY(QQmlListProperty<CallEntry> calls
                    READ calls
                    NOTIFY callsChanged)
+    Q_PROPERTY(bool callIndicatorVisible
+               READ callIndicatorVisible
+               WRITE setCallIndicatorVisible
+               NOTIFY callIndicatorVisibleChanged)
 
 public:
     static CallManager *instance();
@@ -72,6 +76,10 @@
     QList<CallEntry*> takeCalls(const QList<Tp::ChannelPtr> callChannels);
     void addCalls(const QList<CallEntry*> entries);
 
+    // call indicator related
+    bool callIndicatorVisible() const;
+    void setCallIndicatorVisible(bool visible);
+
     // QQmlListProperty helpers
     static int callsCount(QQmlListProperty<CallEntry> *p);
     static CallEntry* callAt(QQmlListProperty<CallEntry> *p, int index);
@@ -85,22 +93,26 @@
     void hasBackgroundCallChanged();
     void speakerChanged();
     void voicemailNumberChanged();
+    void callIndicatorVisibleChanged(bool visible);
 
 public Q_SLOTS:
     void onCallChannelAvailable(Tp::CallChannelPtr channel);
     void onChannelObserverUnregistered();
     void onCallEnded();
     void onConnectedChanged();
+    void onCallIndicatorVisibleChanged(bool visible);
 
 private:
     explicit CallManager(QObject *parent = 0);
     void refreshProperties();
+    void setDBusProperty(const QString &name, const QVariant &value);
     void setupCallEntry(CallEntry *entry);
 
     mutable QList<CallEntry*> mCallEntries;
     QString mVoicemailNumber;
     bool mNeedsUpdate;
     CallEntry *mConferenceCall;
+    bool mCallIndicatorVisible;
 };
 
 #endif // CALLMANAGER_H