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

[Gustavo Pichorim Boiko]

Add VOIP support to telephony-service.

Add VOIP support to telephony-service.

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

967. By Gustavo Pichorim Boiko on 2016-12-09

Remove not needed dependencies

968. By Gustavo Pichorim Boiko on 2016-12-16

Fix DTMF, add more gstreamer debugging and add a protocol file for SIP.

969. By Gustavo Pichorim Boiko on 2016-12-16

Implement mute for CMs that don't use hardware streaming.

970. By Gustavo Pichorim Boiko on 2016-12-16

Play a tone when the call is ringing on the other end.

971. By Gustavo Pichorim Boiko on 2016-12-17

Play the correct tone when the call is ringing.

972. By Gustavo Pichorim Boiko on 2016-12-17

Play the dialing tone before the ringing one.

[Renato Araujo Oliveira Filho (renatofilho)]

Replaced by: https://code.launchpad.net/~phablet-team/telephony-service/voip_support/+merge/3137

review: Disapprove

Unmerged revisions

978. By Gustavo Pichorim Boiko on 2017-01-11

Expose the modem name.

977. By Gustavo Pichorim Boiko on 2017-01-11

Select VOIP accounts by default

976. By Gustavo Pichorim Boiko on 2017-01-04

When matching SIP contacts, extract the phone number from the SIP URI

975. By Gustavo Pichorim Boiko on 2017-01-04

stop the ringing tone when the call ends

974. By Gustavo Pichorim Boiko on 2017-01-04

Iterate over the phone accounts only to set the name

973. By Gustavo Pichorim Boiko on 2017-01-04

Merge staging

972. By Gustavo Pichorim Boiko on 2016-12-17

Play the dialing tone before the ringing one.

971. By Gustavo Pichorim Boiko on 2016-12-17

Play the correct tone when the call is ringing.

970. By Gustavo Pichorim Boiko on 2016-12-16

Play a tone when the call is ringing on the other end.

969. By Gustavo Pichorim Boiko on 2016-12-16

Implement mute for CMs that don't use hardware streaming.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-10-06 19:41:33 +0000
+++ CMakeLists.txt	2016-12-17 13:33:18 +0000
@@ -35,10 +35,8 @@
 
 find_package(Qt5Contacts)
 find_package(Qt5DBus)
-#find_package(Qt5Gui)
 find_package(Qt5Multimedia)
 find_package(Qt5Qml)
-#find_package(Qt5Quick)
 find_package(Qt5Test)
 find_package(Qt5Feedback)
 find_package(Qt5Network)
@@ -71,10 +69,14 @@
 
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(TP_QT5 REQUIRED TelepathyQt5)
+pkg_check_modules(TP_QT5_FS REQUIRED TelepathyQt5Farstream)
 pkg_check_modules(NOTIFY REQUIRED libnotify)
 pkg_check_modules(MESSAGING_MENU REQUIRED messaging-menu)
 pkg_check_modules(UserMetrics REQUIRED libusermetricsinput-1)
 pkg_check_modules(HISTORY REQUIRED history-service)
+pkg_check_modules(TPFS REQUIRED telepathy-farstream)
+pkg_check_modules(GST REQUIRED gstreamer-1.0)
+pkg_check_modules(FS REQUIRED farstream-0.2)
 
 add_definitions(-DQT_NO_KEYWORDS)
 

=== modified file 'handler/CMakeLists.txt'
--- handler/CMakeLists.txt	2016-07-07 22:16:11 +0000
+++ handler/CMakeLists.txt	2016-12-17 13:33:18 +0000
@@ -1,7 +1,9 @@
 
 set(qt_SRCS
+    callagent.cpp
     callhandler.cpp
     chatstartingjob.cpp
+    farstreamchannel.cpp
     handler.cpp
     handlerdbus.cpp
     messagejob.cpp
@@ -16,6 +18,9 @@
 
 include_directories(
     ${TP_QT5_INCLUDE_DIRS}
+    ${TPFS_INCLUDE_DIRS}
+    ${FS_INCLUDE_DIRS}
+    ${GST_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}/libtelephonyservice
     ${CMAKE_CURRENT_BINARY_DIR}
     )
@@ -25,6 +30,9 @@
 
 target_link_libraries(telephony-service-handler
     ${TP_QT5_LIBRARIES}
+    ${TP_QT5_FS_LIBRARIES}
+    ${TPFS_LIBRARIES}
+    ${FS_LIBRARIES}
     telephonyservice
     )
 

=== modified file 'handler/TelephonyServiceHandler.client'
--- handler/TelephonyServiceHandler.client	2016-04-15 22:25:51 +0000
+++ handler/TelephonyServiceHandler.client	2016-12-17 13:33:18 +0000
@@ -6,3 +6,12 @@
 
 [org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 3]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Call1
+
+[org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 1]
+org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Call1
+org.freedesktop.Telepathy.Channel.Type.Call1.InitialAudio b=true
+
+[org.freedesktop.Telepathy.Client.Handler.Capabilities]
+org.freedesktop.Telepathy.Channel.Type.Call1/audio=true
+org.freedesktop.Telepathy.Channel.Type.Call1/ice=true
+org.freedesktop.Telepathy.Channel.Type.Call1/gtalk-p2p=true

=== added file 'handler/callagent.cpp'
--- handler/callagent.cpp	1970-01-01 00:00:00 +0000
+++ handler/callagent.cpp	2016-12-17 13:33:18 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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 "callagent.h"
+#include <TelepathyQt/CallContent>
+#include <TelepathyQt/Contact>
+#include <TelepathyQt/Farstream/Channel>
+#include <QDebug>
+
+CallAgent::CallAgent(const Tp::CallChannelPtr &channel, QObject *parent) :
+    QObject(parent), mChannel(channel), mFarstreamChannel(0)
+{
+    connect(mChannel.data(),
+            SIGNAL(invalidated(Tp::DBusProxy*,QString,QString)),
+            SLOT(onCallChannelInvalidated()));
+    connect(mChannel.data(),
+            SIGNAL(callStateChanged(Tp::CallState)),
+            SLOT(onCallStateChanged(Tp::CallState)));
+    connect(mChannel.data(),
+            SIGNAL(contentAdded(Tp::CallContentPtr)),
+            SLOT(onContentAdded(Tp::CallContentPtr)));
+
+    Q_FOREACH(const Tp::CallContentPtr &content, mChannel->contents()) {
+        onContentAdded(content);
+    }
+
+    if (!mChannel->handlerStreamingRequired()) {
+        return;
+    }
+
+    Tp::Farstream::PendingChannel *pendingChannel = Tp::Farstream::createChannel(mChannel);
+    connect(pendingChannel,
+            SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(onFarstreamChannelCreated(Tp::PendingOperation*)));
+}
+
+CallAgent::~CallAgent()
+{
+    if (mFarstreamChannel) {
+        mFarstreamChannel->deleteLater();
+    }
+}
+
+void CallAgent::setMute(bool mute)
+{
+    if (!mFarstreamChannel) {
+        return;
+    }
+
+    mFarstreamChannel->setMute(mute);
+}
+
+void CallAgent::onCallChannelInvalidated()
+{
+    deleteLater();
+}
+
+void CallAgent::onCallStateChanged(Tp::CallState state)
+{
+    if (state == Tp::CallStatePendingInitiator) {
+        mChannel->accept();
+    }
+}
+
+void CallAgent::onContentAdded(const Tp::CallContentPtr &content)
+{
+    if (!mChannel->handlerStreamingRequired()) {
+        return;
+    }
+
+    qDebug() << "Content Added, name: " << content->name() << " type: " << content->type();
+
+    connect(content.data(),
+            SIGNAL(streamAdded(Tp::CallStreamPtr)),
+            SLOT(onStreamAdded(Tp::CallStreamPtr)));
+
+    Q_FOREACH(const Tp::CallStreamPtr &stream, content->streams()) {
+        onStreamAdded(stream);
+    }
+}
+
+void CallAgent::onStreamAdded(const Tp::CallStreamPtr &stream)
+{
+    qDebug() << "Stream present: " << stream->localSendingState();
+
+    qDebug() << "  members " << stream->remoteMembers().size();
+    Q_FOREACH(const Tp::ContactPtr contact, stream->remoteMembers()) {
+        qDebug() << "    member " << contact->id() << " remoteSendingState=" << stream->remoteSendingState(contact);
+    }
+}
+
+void CallAgent::onFarstreamChannelCreated(Tp::PendingOperation *op)
+{
+    Tp::Farstream::PendingChannel *pendingChannel = qobject_cast<Tp::Farstream::PendingChannel*>(op);
+    if (!pendingChannel) {
+        return;
+    }
+
+    mFarstreamChannel = new FarstreamChannel(pendingChannel->tfChannel(), this);
+}

=== added file 'handler/callagent.h'
--- handler/callagent.h	1970-01-01 00:00:00 +0000
+++ handler/callagent.h	2016-12-17 13:33:18 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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 CALLAGENT_H
+#define CALLAGENT_H
+
+#include <QObject>
+#include <TelepathyQt/CallChannel>
+#include <TelepathyQt/Farstream/Channel>
+#include "farstreamchannel.h"
+
+class CallAgent : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CallAgent(const Tp::CallChannelPtr &channel, QObject *parent = 0);
+    ~CallAgent();
+
+    void setMute(bool mute);
+
+protected Q_SLOTS:
+    void onCallChannelInvalidated();
+    void onCallStateChanged(Tp::CallState state);
+    void onContentAdded(const Tp::CallContentPtr &content);
+    void onStreamAdded(const Tp::CallStreamPtr &stream);
+
+    void onFarstreamChannelCreated(Tp::PendingOperation *op);
+
+private:
+    Tp::CallChannelPtr mChannel;
+    FarstreamChannel *mFarstreamChannel;
+};
+
+#endif // CALLAGENT_H

=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2015-07-06 23:32:13 +0000
+++ handler/callhandler.cpp	2016-12-17 13:33:18 +0000
@@ -20,15 +20,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "callagent.h"
 #include "callhandler.h"
-#include "phoneutils.h"
 #include "telepathyhelper.h"
 #include "accountentry.h"
 #include "tonegenerator.h"
 #include "greetercontacts.h"
+#include "phoneutils.h"
 #include <TelepathyQt/ContactManager>
 #include <TelepathyQt/PendingContacts>
 #include <TelepathyQt/PendingChannelRequest>
+#include <TelepathyQt/PendingVariant>
+#include <memory>
 
 #define TELEPATHY_MUTE_IFACE "org.freedesktop.Telepathy.Call1.Interface.Mute"
 #define DBUS_PROPERTIES_IFACE "org.freedesktop.DBus.Properties"
@@ -72,8 +75,7 @@
     bool hasActiveCalls = false;
 
     Q_FOREACH(const Tp::CallChannelPtr channel, mCallChannels) {
-        AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(channel->connection());
-        bool incoming = channel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+        bool incoming = isIncoming(channel);
         bool dialing = !incoming && (channel->callState() == Tp::CallStateInitialised);
         bool active = channel->callState() == Tp::CallStateActive;
 
@@ -94,6 +96,7 @@
 
 void CallHandler::startCall(const QString &targetId, const QString &accountId)
 {
+    QString finalId = targetId;
     // Request the contact to start audio call
     AccountEntry *accountEntry = TelepathyHelper::instance()->accountForId(accountId);
     if (!accountEntry) {
@@ -105,7 +108,20 @@
         return;
     }
 
-    connect(connection->contactManager()->contactsForIdentifiers(QStringList() << targetId),
+    // FIXME: this is a workaround, there might be a better way of handling this.
+    // One idea is to implement the Addressing interface on the SIP connection manager such that
+    // we can request a handle based on the vCard field "tel"
+    if (accountEntry->protocolInfo()->name() == "sip") {
+        // in case this is a SIP call, replace the numbers by a SIP URI
+        QString domain = accountEntry->account()->parameters()["account"].toString();
+        if (domain.contains("@")) {
+            domain = domain.split("@")[1];
+
+            finalId = QString("sip:%1@%2").arg(PhoneUtils::normalizePhoneNumber(targetId)).arg(domain);
+        }
+    }
+
+    connect(connection->contactManager()->contactsForIdentifiers(QStringList() << finalId),
             SIGNAL(finished(Tp::PendingOperation*)),
             SLOT(onContactsAvailable(Tp::PendingOperation*)));
 }
@@ -146,9 +162,17 @@
         return;
     }
 
-    // FIXME: replace by a proper TpQt implementation of mute
-    QDBusInterface muteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE);
-    muteInterface.call("RequestMuted", muted);
+    if (channel->handlerStreamingRequired()) {
+        CallAgent *agent = mCallAgents[channel.data()];
+        if (!agent) {
+            return;
+        }
+        agent->setMute(muted);
+    } else {
+        // FIXME: replace by a proper TpQt implementation of mute
+        QDBusInterface muteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE);
+        muteInterface.call("RequestMuted", muted);
+    }
 }
 
 void CallHandler::setActiveAudioOutput(const QString &objectPath, const QString &id)
@@ -161,26 +185,15 @@
 
 void CallHandler::sendDTMF(const QString &objectPath, const QString &key)
 {
-    bool ok;
-    Tp::DTMFEvent event = (Tp::DTMFEvent)key.toInt(&ok);
-    if (!ok) {
-         if (!key.compare("*")) {
-             event = Tp::DTMFEventAsterisk;
-         } else if (!key.compare("#")) {
-             event = Tp::DTMFEventHash;
-         } else {
-             qWarning() << "Tone not recognized. DTMF failed";
-             return;
-         }
-    }
     /*
-     * play locally (via tone generator) only if we are on a call, or if this is 
+     * play locally (via tone generator) only if we are on a call, or if this is
      * dialpad sounds
      */
-    if (GreeterContacts::instance()->dialpadSoundsEnabled() && 
+    int event = toDTMFEvent(key);
+    if (GreeterContacts::instance()->dialpadSoundsEnabled() &&
         !GreeterContacts::instance()->silentMode() && objectPath.isEmpty()
         || !objectPath.isEmpty()) {
-        ToneGenerator::instance()->playDTMFTone((uint)event);
+        ToneGenerator::instance()->playDTMFTone(event);
     }
 
     Tp::CallChannelPtr channel = callFromObjectPath(objectPath);
@@ -190,14 +203,15 @@
 
     // save the dtmfString to send to clients that request it
     QString dtmfString = channel->property("dtmfString").toString();
+    QString pendingDTMF = channel->property("pendingDTMF").toString();
+    pendingDTMF += key;
     dtmfString += key;
     channel->setProperty("dtmfString", dtmfString);
+    channel->setProperty("pendingDTMF", pendingDTMF);
 
-    Q_FOREACH(const Tp::CallContentPtr &content, channel->contents()) {
-        if (content->supportsDTMF()) {
-            /* send DTMF to network (via telepathy and oFono) */
-            content->startDTMFTone(event);
-        }
+    // if there is only one pending DTMF event, start playing it
+    if (pendingDTMF.length() == 1) {
+        playNextDTMFTone(channel);
     }
 
     Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
@@ -273,6 +287,8 @@
 
     if (channel->callState() == Tp::CallStateActive) {
         channel->setProperty("activeTimestamp", QDateTime::currentDateTimeUtc());
+    } else if (channel->callState() == Tp::CallStatePendingInitiator) {
+        channel->accept();
     }
 
     connect(channel.data(),
@@ -282,6 +298,10 @@
             SIGNAL(callStateChanged(Tp::CallState)),
             SLOT(onCallStateChanged(Tp::CallState)));
 
+    // FIXME: save this to a list
+    CallAgent *agent = new CallAgent(channel, this);
+    mCallAgents[channel.data()] = agent;
+
     mCallChannels.append(channel);
     Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
 }
@@ -331,6 +351,10 @@
     }
 
     mCallChannels.removeAll(channel);
+    if (mCallAgents.contains(channel.data())) {
+        CallAgent *agent = mCallAgents.take(channel.data());
+        agent->deleteLater();
+    }
 
     if (mCallChannels.isEmpty() && !mHangupRequested) {
         ToneGenerator::instance()->playCallEndedTone();
@@ -346,7 +370,22 @@
     }
 
     switch (state) {
+    case Tp::CallStatePendingInitiator:
+    case Tp::CallStateInitialising:
+        if (!isIncoming(channel) && channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->playDialingTone();
+        }
+        break;
+    case Tp::CallStateInitialised:
+        if (!isIncoming(channel) && channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->stopTone();
+            ToneGenerator::instance()->playRingingTone();
+        }
+        break;
     case Tp::CallStateActive:
+        if (channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->stopTone();
+        }
         channel->setProperty("activeTimestamp", QDateTime::currentDateTimeUtc());
         Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
         break;
@@ -387,3 +426,101 @@
 
     return channel;
 }
+
+void CallHandler::playNextDTMFTone(Tp::CallChannelPtr channel)
+{
+    // the channel might have been closed already
+    if (!channel) {
+        return;
+    }
+
+    QString pendingDTMF = channel->property("pendingDTMF").toString();
+    QString key = "";
+    if (!pendingDTMF.isEmpty()) {
+        key = pendingDTMF[0];
+    }
+
+    int event = toDTMFEvent(key);
+
+    Q_FOREACH(const Tp::CallContentPtr &content, channel->contents()) {
+        if (content->supportsDTMF()) {
+
+            /* stop any previous DTMF tone before sending the new one*/
+            connect(content->stopDTMFTone(), &Tp::PendingOperation::finished, [=](Tp::PendingOperation *op){
+                // in case stopDTMFTone, it might mean the service automatically stops the tone,
+                // so try playing the next one
+                if (op->isError()) {
+                    /* send DTMF to network (via telepathy) */
+                    if (event >= 0) {
+                        content->startDTMFTone((Tp::DTMFEvent)event);
+                    }
+                    triggerNextDTMFTone(channel);
+                    return;
+                }
+
+                Tp::Client::CallContentInterfaceDTMFInterface *dtmfInterface = content->interface<Tp::Client::CallContentInterfaceDTMFInterface>();
+                Tp::PendingVariant *pv = dtmfInterface->requestPropertyCurrentlySendingTones();
+                connect(pv, &Tp::PendingOperation::finished, [=](){
+                    bool sendingTones = pv->result().toBool();
+                    // if we already stopped sending tones, we can send the next one
+                    if (!sendingTones) {
+                        /* send DTMF to network (via telepathy) */
+                        if (event >= 0) {
+                            content->startDTMFTone((Tp::DTMFEvent)event);
+                        }
+                        triggerNextDTMFTone(channel);
+                        return;
+                    }
+
+                    // in case the previous tone is not finished, we need to wait for it
+                    auto conn = std::make_shared<QMetaObject::Connection>();
+                    *conn = connect(dtmfInterface, &Tp::Client::CallContentInterfaceDTMFInterface::StoppedTones, [=](){
+                        QObject::disconnect(*conn);
+
+                        /* send DTMF to network (via telepathy) */
+                        if (event >= 0) {
+                            content->startDTMFTone((Tp::DTMFEvent)event);
+                        }
+                        triggerNextDTMFTone(channel);
+                    });
+                });
+
+            });
+        }
+    }
+}
+
+void CallHandler::triggerNextDTMFTone(Tp::CallChannelPtr channel)
+{
+    QTimer::singleShot(250, [=](){
+        QString pendingDTMF = channel->property("pendingDTMF").toString();
+        if (pendingDTMF.isEmpty()) {
+            return;
+        }
+        pendingDTMF.remove(0, 1);
+        channel->setProperty("pendingDTMF", pendingDTMF);
+        playNextDTMFTone(channel);
+    });
+}
+
+int CallHandler::toDTMFEvent(const QString &key)
+{
+    bool ok;
+    int ev = key.toInt(&ok);
+    if (!ok) {
+         if (key == "*") {
+             ev = Tp::DTMFEventAsterisk;
+         } else if (key == "#") {
+             ev = Tp::DTMFEventHash;
+         } else {
+             ev = -1;
+         }
+    }
+    return ev;
+}
+
+bool CallHandler::isIncoming(const Tp::CallChannelPtr &channel) const
+{
+    AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(channel->connection());
+    return channel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+}

=== modified file 'handler/callhandler.h'
--- handler/callhandler.h	2015-03-04 18:02:13 +0000
+++ handler/callhandler.h	2016-12-17 13:33:18 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2013 Canonical, Ltd.
+ * Copyright (C) 2012-2014 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -28,6 +28,7 @@
 #include <TelepathyQt/CallChannel>
 
 class TelepathyHelper;
+class CallAgent;
 
 class CallHandler : public QObject
 {
@@ -61,6 +62,11 @@
     Tp::CallChannelPtr existingCall(const QString &targetId);
     Tp::CallChannelPtr callFromObjectPath(const QString &objectPath);
 
+    void playNextDTMFTone(Tp::CallChannelPtr channel);
+    void triggerNextDTMFTone(Tp::CallChannelPtr channel);
+    static int toDTMFEvent(const QString &key);
+    bool isIncoming(const Tp::CallChannelPtr &channel) const;
+
 protected Q_SLOTS:
     void onContactsAvailable(Tp::PendingOperation *op);
     void onCallHangupFinished(Tp::PendingOperation *op);
@@ -72,6 +78,7 @@
 
     QMap<QString, Tp::ContactPtr> mContacts;
     QList<Tp::CallChannelPtr> mCallChannels;
+    QMap<Tp::CallChannel*,CallAgent*> mCallAgents;
     QMap<Tp::PendingOperation*,Tp::CallChannelPtr> mClosingChannels;
     bool mHangupRequested;
 };

=== added file 'handler/farstreamchannel.cpp'
--- handler/farstreamchannel.cpp	1970-01-01 00:00:00 +0000
+++ handler/farstreamchannel.cpp	2016-12-17 13:33:18 +0000
@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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 "farstreamchannel.h"
+#include <farstream/fs-utils.h>
+#include <QDebug>
+
+FarstreamChannel::FarstreamChannel(TfChannel *channel, QObject *parent) :
+    mChannel(channel), QObject(parent), mPipeline(0), mBus(0), mBusSource(0),
+    mConferenceAddedSignal(0), mConferenceRemovedSignal(0), mContentAddedSignal(0),
+    mContentRemovedSignal(0), mAudioInput(0), mAudioOutput(0)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    initialize();
+}
+
+FarstreamChannel::~FarstreamChannel()
+{
+    // stop audio input and output
+    if (mAudioInput) {
+        setState(mAudioInput, GST_STATE_NULL);
+        gst_object_unref(mAudioInput);
+    }
+
+    if (mAudioOutput) {
+        setState(mAudioOutput, GST_STATE_NULL);
+        gst_object_unref(mAudioOutput);
+    }
+
+    // now clear the notifiers
+    Q_FOREACH(FsElementAddedNotifier *notifier, mNotifiers) {
+        fs_element_added_notifier_remove(notifier, GST_BIN(mPipeline));
+        g_object_unref(notifier);
+    }
+    mNotifiers.clear();
+
+    // clear the bus stuff
+    if (mBusSource) {
+        g_source_remove(mBusSource);
+    }
+
+    if (mBus) {
+        gst_object_unref(mBus);
+    }
+
+    // and finally the pipeline
+    if (mPipeline) {
+        setState(mPipeline, GST_STATE_NULL);
+        gst_object_unref(mPipeline);
+    }
+}
+
+void FarstreamChannel::setMute(bool mute)
+{
+    GstElement *input_volume = gst_bin_get_by_name(GST_BIN(mPipeline), "input_volume");
+    g_object_set(input_volume, "mute", mute, NULL);
+    g_object_unref(input_volume);
+}
+
+void FarstreamChannel::initialize()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // connect all the signals
+    mConferenceAddedSignal = g_signal_connect(mChannel, "fs-conference-added",
+                                              G_CALLBACK(&FarstreamChannel::onConferenceAdded),
+                                              this);
+    mConferenceRemovedSignal = g_signal_connect(mChannel, "fs-conference-removed",
+                                                G_CALLBACK(&FarstreamChannel::onConferenceRemoved),
+                                                this);
+    mContentAddedSignal = g_signal_connect(mChannel, "content-added",
+                                           G_CALLBACK(&FarstreamChannel::onContentAdded),
+                                           this);
+    mContentRemovedSignal = g_signal_connect(mChannel, "content-removed",
+                                             G_CALLBACK(&FarstreamChannel::onContentRemoved),
+                                             this);
+
+    // and initialize the gstreamer pipeline
+    mPipeline = gst_pipeline_new(NULL);
+    if (!mPipeline) {
+        qCritical() << "Failed to create GStreamer pipeline.";
+        return;
+    }
+
+    mBus = gst_pipeline_get_bus(GST_PIPELINE(mPipeline));
+    if (!mBus) {
+        qCritical() << "Failed to get GStreamer pipeline bus.";
+        return;
+    }
+
+    mBusSource = gst_bus_add_watch(mBus, (GstBusFunc) &FarstreamChannel::onBusWatch, this);
+
+    if (!setState(mPipeline, GST_STATE_PLAYING)) {
+        return;
+    }
+}
+
+GstElement *FarstreamChannel::initializeAudioSource(TfContent *content)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    GstElement *element = gst_parse_bin_from_description ("pulsesrc ! audio/x-raw, rate=8000 ! queue"
+                                                          " ! audioconvert ! audioresample"
+                                                          " ! volume name=input_volume ! audioconvert ",
+                                                          TRUE, NULL);
+    gint input_volume = 0;
+    g_object_get (content, "requested-input-volume", &input_volume, NULL);
+
+    if (input_volume >= 0) {
+        GstElement *volume = gst_bin_get_by_name (GST_BIN (element), "input_volume");
+        g_object_set (volume, "volume", (double)input_volume / 255.0, NULL);
+        gst_object_unref (volume);
+    }
+
+    // FIXME: we probably need to handle input volume request changes
+    mAudioOutput = element;
+    return element;
+}
+
+bool FarstreamChannel::addToPipeline(GstElement *element)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element);
+    if (!mPipeline) {
+        qWarning() << "No gstreamer pipeline found.";
+        return false;
+    }
+
+    if (!gst_bin_add(GST_BIN(mPipeline), element)) {
+        qCritical() << "Failed to add bin" << GST_ELEMENT_NAME(element) << "to pipeline.";
+        return false;
+    }
+    qDebug() << "Succeeded adding to pipeline!";
+    return true;
+}
+
+void FarstreamChannel::removeFromPipeline(GstElement *element)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element);
+    gst_element_set_locked_state(element, TRUE);
+    setState(element, GST_STATE_NULL);
+    gst_bin_remove (GST_BIN (mPipeline), element);
+}
+
+bool FarstreamChannel::setState(GstElement *element, GstState state)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element) << gst_element_state_get_name(state);
+    GstStateChangeReturn result = gst_element_set_state(element, state);
+    if (result == GST_STATE_CHANGE_FAILURE) {
+        qCritical() << "Failed to set GStreamer element" << GST_ELEMENT_NAME(element) << "state to" << gst_element_state_get_name(state);
+        return false;
+    }
+    qDebug() << "Succeeded playing!";
+    return true;
+}
+
+gboolean FarstreamChannel::onBusWatch(GstBus *bus, GstMessage *message, FarstreamChannel *self)
+{
+    Q_UNUSED(bus)
+    if (!self->mChannel) {
+        return TRUE;
+    }
+
+    // FIXME: maybe we need to do some error handling here?
+    tf_channel_bus_message(self->mChannel, message);
+    return TRUE;
+}
+
+void FarstreamChannel::onConferenceAdded(TfChannel *channel, FsConference *conference, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel)
+
+    /* Add notifier to set the various element properties as needed */
+    GKeyFile *keyfile = fs_utils_get_default_element_properties (GST_ELEMENT(conference));
+    if (keyfile != NULL) {
+        qDebug() << "Loaded default properties for" << GST_ELEMENT_NAME(conference);
+        FsElementAddedNotifier *notifier = fs_element_added_notifier_new();
+        fs_element_added_notifier_set_properties_from_keyfile(notifier, keyfile);
+        fs_element_added_notifier_add(notifier, GST_BIN(self->mPipeline));
+
+        // FIXME: right now we are leaking the notifiers, check when to remove them
+        self->mNotifiers.append(notifier);
+    }
+
+    if (!self->addToPipeline(GST_ELEMENT(conference))) {
+        return;
+    }
+
+    self->setState(GST_ELEMENT(conference), GST_STATE_PLAYING);
+}
+
+void FarstreamChannel::onConferenceRemoved(TfChannel *channel, FsConference *conference, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel);
+
+    // just remove the conference from the pipeline
+    self->removeFromPipeline(GST_ELEMENT(conference));
+}
+
+void FarstreamChannel::onContentAdded(TfChannel *channel, TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel)
+
+    g_signal_connect(content, "src-pad-added",
+                     G_CALLBACK(&FarstreamChannel::onSrcPadAdded), self);
+    g_signal_connect(content, "start-sending",
+                     G_CALLBACK(&FarstreamChannel::onStartSending), self);
+    g_signal_connect(content, "stop-sending",
+                     G_CALLBACK(&FarstreamChannel::onStopSending), self);
+}
+
+void FarstreamChannel::onContentRemoved(TfChannel *channel, TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // FIXME: implement
+}
+
+bool FarstreamChannel::onStartSending(TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    GstPad *sinkPad;
+    FsMediaType mediaType;
+    GstElement *element;
+
+    g_object_get (content, "sink-pad", &sinkPad, "media-type", &mediaType, NULL);
+
+    switch (mediaType) {
+    case FS_MEDIA_TYPE_AUDIO:
+        element = self->initializeAudioSource(content);
+        break;
+    // FIXME: add video support
+    default:
+        qWarning() << "Unsupported media type:" << mediaType;
+        g_object_unref(sinkPad);
+        return false;
+    }
+
+    if (!self->addToPipeline(element)) {
+        g_object_unref(sinkPad);
+        return false;
+    }
+
+    GstPad *sourcePad = gst_element_get_static_pad (element, "src");
+    if (GST_PAD_LINK_FAILED (gst_pad_link (sourcePad, sinkPad))) {
+        qCritical() << "Failed to link source pad to content's sink pad";
+        g_object_unref(sinkPad);
+        g_object_unref(sourcePad);
+        return false;
+    }
+
+    self->setState(element, GST_STATE_PLAYING);
+    self->mAudioInput = element;
+
+    g_object_unref(sinkPad);
+    g_object_unref(sourcePad);
+
+    qDebug() << "BLABLA generating dot file";
+    GST_DEBUG_BIN_TO_DOT_FILE (GST_BIN (self->mPipeline),
+         GST_DEBUG_GRAPH_SHOW_ALL, "telephony-service-gst");
+    qDebug() << "BLABLA done!";
+    return true;
+}
+
+void FarstreamChannel::onStopSending(TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // FIXME: implement
+}
+
+void FarstreamChannel::onSrcPadAdded(TfContent *content, uint handle, FsStream *stream, GstPad *pad, FsCodec *codec, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    gchar *codecString = fs_codec_to_string (codec);
+    qDebug() << __PRETTY_FUNCTION__ << "Codec:" << codecString;
+
+    FsMediaType mediaType;
+    GstElement *element;
+
+    g_object_get (content, "media-type", &mediaType, NULL);
+
+    switch (mediaType) {
+    case FS_MEDIA_TYPE_AUDIO: {
+         QString outputVolume = QString("output_volume%1").arg(codecString);
+         QString description = QString("audioconvert ! audioresample "
+                                       "! volume name=\"%1\" "
+                                       "! audioconvert ! autoaudiosink").arg(outputVolume);
+         element = gst_parse_bin_from_description (description.toUtf8().data(), TRUE, NULL);
+         GstElement *volume = gst_bin_get_by_name (GST_BIN (element), outputVolume.toUtf8().data());
+
+         // FIXME: we need to handle volume request changes in the volume element
+         gst_object_unref (volume);
+         break;
+    }
+    // FIXME: handle video
+    default:
+        qWarning() << "Unsupported media type:" << mediaType;
+        return;
+    }
+
+    if (!self->addToPipeline(element)) {
+        return;
+    }
+
+    GstPad *sinkPad = gst_element_get_static_pad (element, "sink");
+    if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sinkPad))) {
+        qCritical() << "Failed to link content's source pad to local sink pad";
+    }
+
+    self->setState(element, GST_STATE_PLAYING);
+
+    g_object_unref (sinkPad);
+}

=== added file 'handler/farstreamchannel.h'
--- handler/farstreamchannel.h	1970-01-01 00:00:00 +0000
+++ handler/farstreamchannel.h	2016-12-17 13:33:18 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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 FARSTREAMCHANNEL_H
+#define FARSTREAMCHANNEL_H
+
+#include <QObject>
+#include <QList>
+#include <telepathy-farstream/telepathy-farstream.h>
+#include <farstream/fs-conference.h>
+#include <farstream/fs-stream.h>
+#include <farstream/fs-element-added-notifier.h>
+
+class FarstreamChannel : public QObject
+{
+    Q_OBJECT
+public:
+    explicit FarstreamChannel(TfChannel *channel, QObject *parent = 0);
+    ~FarstreamChannel();
+
+    void setMute(bool mute);
+
+protected:
+    void initialize();
+    GstElement *initializeAudioSource(TfContent *content);
+
+    // gstreamer helpers
+    bool addToPipeline(GstElement *element);
+    void removeFromPipeline(GstElement *bin);
+    bool setState(GstElement *element, GstState state);
+
+    // glib signal handlers
+    static gboolean onBusWatch(GstBus *bus, GstMessage *message, FarstreamChannel *self);
+    static void onConferenceAdded(TfChannel *channel, FsConference *conference, FarstreamChannel *self);
+    static void onConferenceRemoved(TfChannel *channel, FsConference *conference, FarstreamChannel *self);
+    static void onContentAdded(TfChannel *channel, TfContent * content, FarstreamChannel *self);
+    static void onContentRemoved(TfChannel *channel, TfContent * content, FarstreamChannel *self);
+    static bool onStartSending(TfContent *content, FarstreamChannel *self);
+    static void onStopSending(TfContent *content, FarstreamChannel *self);
+    static void onSrcPadAdded(TfContent *content, uint handle, FsStream *stream, GstPad *pad, FsCodec *codec, FarstreamChannel *self);
+
+private:
+    TfChannel *mChannel;
+
+    // gstreamer stuff
+    GstElement *mPipeline;
+    GstBus *mBus;
+    uint mBusSource;
+    GstElement *mAudioInput;
+    GstElement *mAudioOutput;
+
+    // signal IDs
+    gulong mConferenceAddedSignal;
+    gulong mConferenceRemovedSignal;
+    gulong mContentAddedSignal;
+    gulong mContentRemovedSignal;
+
+    // farstream stuff
+    QList<FsElementAddedNotifier*> mNotifiers;
+};
+
+#endif // FARSTREAMCHANNEL_H

=== modified file 'handler/handler.cpp'
--- handler/handler.cpp	2016-11-23 19:28:18 +0000
+++ handler/handler.cpp	2016-12-17 13:33:18 +0000
@@ -32,7 +32,7 @@
 #include <TelepathyQt/PendingReady>
 
 Handler::Handler(QObject *parent)
-    : QObject(parent), Tp::AbstractClientHandler(channelFilters())
+    : QObject(parent), Tp::AbstractClientHandler(channelFilters(), capabilities())
 {
 }
 
@@ -102,9 +102,22 @@
     specList << Tp::ChannelClassSpec::textChatroom();
     specList << Tp::ChannelClassSpec::unnamedTextChat();
 
+    QVariantMap props;
+    props[TP_QT_IFACE_CHANNEL_TYPE_CALL + ".InitialAudio"] = true;
+    specList << Tp::ChannelClassSpec::audioCall(props);
+
     return specList;
 }
 
+Tp::AbstractClientHandler::Capabilities Handler::capabilities()
+{
+    QStringList caps;
+    caps << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/shm"
+         << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/ice"
+         << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/gtalk-p2p";
+    return Tp::AbstractClientHandler::Capabilities(caps);
+}
+
 void Handler::onTextChannelReady(Tp::PendingOperation *op)
 {
     Tp::PendingReady *pr = qobject_cast<Tp::PendingReady*>(op);
@@ -133,6 +146,7 @@
 
 void Handler::onCallChannelReady(Tp::PendingOperation *op)
 {
+    qDebug() << "BLABLA" << __PRETTY_FUNCTION__;
     Tp::PendingReady *pr = qobject_cast<Tp::PendingReady*>(op);
 
     if (!pr) {
@@ -155,11 +169,16 @@
     // if the call is neither Accepted nor Active, it means it got dispatched directly to the handler without passing
     // through any approver. For phone calls, this would mean calls getting auto-accepted which is not desirable
     // so we return an error here
-    bool incoming = false;
+    bool incoming = !callChannel->isRequested();
+    qDebug() << "BLABLA Is requested:" << !incoming;
     AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
-    if (accountEntry) {
-        incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+    qDebug() << "BLABLA accountEntry:" << accountEntry;
+    if (accountEntry &&
+        !callChannel->initiatorContact().isNull() &&
+        callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact()) {
+        incoming = true;
     }
+    qDebug() << "BLABLA incoming:" << incoming;
     if (incoming && callChannel->callState() != Tp::CallStateAccepted && callChannel->callState() != Tp::CallStateActive) {
         qWarning() << "Available channel was not approved by telephony-service-approver, ignoring it.";
         if (context) {

=== modified file 'handler/handler.h'
--- handler/handler.h	2015-07-01 22:04:30 +0000
+++ handler/handler.h	2016-12-17 13:33:18 +0000
@@ -45,6 +45,7 @@
                         const QDateTime &userActionTime,
                         const Tp::AbstractClientHandler::HandlerInfo &handlerInfo);
     Tp::ChannelClassSpecList channelFilters();
+    Tp::AbstractClientHandler::Capabilities capabilities();
 
 Q_SIGNALS:
     void textChannelAvailable(Tp::TextChannelPtr textChannel);

=== modified file 'handler/main.cpp'
--- handler/main.cpp	2016-11-23 19:28:18 +0000
+++ handler/main.cpp	2016-12-17 13:33:18 +0000
@@ -30,6 +30,7 @@
 #include <TelepathyQt/AbstractClient>
 #include <TelepathyQt/AccountManager>
 #include <TelepathyQt/Contact>
+#include <telepathy-farstream/telepathy-farstream.h>
 
 int main(int argc, char **argv)
 {
@@ -37,6 +38,7 @@
     QCoreApplication::setApplicationName("telephony-service-handler");
 
     Tp::registerTypes();
+    gst_init(&argc, &argv);
 
     // check if there is already an instance of the handler running
     if (ApplicationUtils::checkApplicationRunning(TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler")) {

=== modified file 'libtelephonyservice/accountentry.cpp'
--- libtelephonyservice/accountentry.cpp	2016-10-05 19:15:39 +0000
+++ libtelephonyservice/accountentry.cpp	2016-12-17 13:33:18 +0000
@@ -28,6 +28,10 @@
 
 Q_DECLARE_METATYPE(Tp::ConnectionPtr);
 
+namespace C {
+#include <libintl.h>
+}
+
 AccountEntry::AccountEntry(const Tp::AccountPtr &account, QObject *parent) :
     QObject(parent), mAccount(account), mReady(false), mProtocol(0)
 {
@@ -51,10 +55,19 @@
 
 bool AccountEntry::active() const
 {
-    return (!mAccount.isNull() &&
-            !mAccount->connection().isNull() &&
-            !mAccount->connection()->selfContact().isNull() &&
-             mAccount->connection()->selfContact()->presence().type() != Tp::ConnectionPresenceTypeOffline);
+    if (mAccount.isNull() || mAccount->connection().isNull() || mAccount->connection()->status() != Tp::ConnectionStatusConnected) {
+        return false;
+    }
+
+    // we have to check if the account supports simple presence. In case it does, we use the self contact presence to determine
+    // if this account is active.
+    if (mAccount->connection()->hasInterface(TP_QT_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE)) {
+        return (!mAccount->connection()->selfContact().isNull() &&
+                mAccount->connection()->selfContact()->presence().type() != Tp::ConnectionPresenceTypeOffline);
+    }
+
+    // if it doesn't support simple presence, we  consider it online by having a connection in connected state
+    return true;
 }
 
 QString AccountEntry::displayName() const

=== modified file 'libtelephonyservice/callentry.cpp'
--- libtelephonyservice/callentry.cpp	2015-06-09 21:59:29 +0000
+++ libtelephonyservice/callentry.cpp	2016-12-17 13:33:18 +0000
@@ -281,11 +281,15 @@
 
 bool CallEntry::incoming() const
 {
-    if (!mAccount) {
-        return false;
+    bool isIncoming = !mChannel->isRequested();
+
+    if (mAccount &&
+        !mChannel->initiatorContact().isNull() &&
+        mChannel->initiatorContact() != mAccount->account()->connection()->selfContact()) {
+        isIncoming = true;
     }
 
-    return mChannel->initiatorContact() != mAccount->account()->connection()->selfContact();
+    return isIncoming;
 }
 
 bool CallEntry::ringing() const
@@ -428,10 +432,18 @@
 {
     QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
     phoneAppHandler->call("SetMuted", mChannel->objectPath(), value);
+
+    // FIXME: maybe we should retrieve the property from the handler instead of relying on telepathy
+    // for that, because on channels that are not using hardware streaming we handle the mute internally
+    // with no participation of the Telepathy mute interface
+    if (mChannel->handlerStreamingRequired()) {
+        onMutedChanged(value ? 1 : 0);
+    }
 }
 
 void CallEntry::onCallStateChanged(Tp::CallState state)
 {
+    qDebug() << __PRETTY_FUNCTION__ << state;
     // fetch the channel properties from the handler
     updateChannelProperties();
 

=== modified file 'libtelephonyservice/callentry.h'
--- libtelephonyservice/callentry.h	2015-03-04 18:02:13 +0000
+++ libtelephonyservice/callentry.h	2016-12-17 13:33:18 +0000
@@ -46,7 +46,7 @@
                READ isVoicemail
                WRITE setVoicemail
                NOTIFY voicemailChanged)
-    Q_PROPERTY(AccountEntry *account READ account)
+    Q_PROPERTY(AccountEntry *account READ account CONSTANT)
 
     // FIXME: replace this by a more generic identifier to support accounts not based on phone numbers
     // this property is only filled for 1-1 calls

=== modified file 'libtelephonyservice/tonegenerator.cpp'
--- libtelephonyservice/tonegenerator.cpp	2015-04-16 21:39:16 +0000
+++ libtelephonyservice/tonegenerator.cpp	2016-12-17 13:33:18 +0000
@@ -69,6 +69,7 @@
 
 void ToneGenerator::playDTMFTone(uint key)
 {
+    qDebug() << __PRETTY_FUNCTION__ << key;
     if (key > 11) {
         qDebug() << "Invalid DTMF tone, ignore.";
         return;
@@ -124,3 +125,13 @@
     startEventTone(CALL_ENDED_TONE);
     QTimer::singleShot(2000, this, SLOT(stopTone()));
 }
+
+void ToneGenerator::playDialingTone()
+{
+    startEventTone(DIALING_TONE);
+}
+
+void ToneGenerator::playRingingTone()
+{
+    startEventTone(RINGING_TONE);
+}

=== modified file 'libtelephonyservice/tonegenerator.h'
--- libtelephonyservice/tonegenerator.h	2015-04-16 21:39:16 +0000
+++ libtelephonyservice/tonegenerator.h	2016-12-17 13:33:18 +0000
@@ -31,6 +31,8 @@
 static const int WAITING_PLAYBACK_DURATION = 8000; /* in milliseconds */
 static const uint WAITING_TONE = 79;
 static const uint CALL_ENDED_TONE = 257;
+static const uint DIALING_TONE = 66;
+static const uint RINGING_TONE = 70;
 
 class ToneGenerator : public QObject
 {
@@ -47,9 +49,11 @@
     void playWaitingTone();
     void stopWaitingTone();
     void playCallEndedTone();
+    void playDialingTone();
+    void playRingingTone();
+    void stopTone();
 
 private Q_SLOTS:
-    void stopTone();
     void stopDTMFTone();
     bool startEventTone(uint key);
 

=== added file 'protocols/sip.protocol'
--- protocols/sip.protocol	1970-01-01 00:00:00 +0000
+++ protocols/sip.protocol	2016-12-17 13:33:18 +0000
@@ -0,0 +1,7 @@
+[Protocol]
+Name=sip
+Features=voice
+FallbackProtocol=
+BackgroundImage=/usr/share/telephony-service/assets/message_watermark.png
+ShowOnSelector=1
+ServiceDisplayName=SIP