Merge lp:~phablet-team/telephony-service/audio_route_manager into lp:telephony-service

[Gustavo Pichorim Boiko]

Implement AudioRouteManager in telephony-service-handler

Implement AudioRouteManager in telephony-service-handler

[lp:~phablet-team/telephony-service/audio_route_manager]

1242. By Renato Araujo Oliveira Filho on 2017-02-03

Parent merged.

1243. By Gustavo Pichorim Boiko on 2017-02-06

Merge parent

1244. By Gustavo Pichorim Boiko on 2017-02-06

Fix building.

1245. By Gustavo Pichorim Boiko on 2017-02-06

Build the pulseaudio stuff on all supported architectures.

1246. By Tiago Salem Herrmann on 2017-02-09

merge parent branch

1247. By Tiago Salem Herrmann on 2017-02-10

merge parent branch

1248. By Tiago Salem Herrmann on 2017-03-03

merge parent branch

Unmerged revisions

1248. By Tiago Salem Herrmann on 2017-03-03

merge parent branch

1247. By Tiago Salem Herrmann on 2017-02-10

merge parent branch

1246. By Tiago Salem Herrmann on 2017-02-09

merge parent branch

1245. By Gustavo Pichorim Boiko on 2017-02-06

Build the pulseaudio stuff on all supported architectures.

1244. By Gustavo Pichorim Boiko on 2017-02-06

Fix building.

1243. By Gustavo Pichorim Boiko on 2017-02-06

Merge parent

1242. By Renato Araujo Oliveira Filho on 2017-02-03

Parent merged.

1241. By Gustavo Pichorim Boiko on 2017-02-03

Initial code to move audio outputs to telephony-service (code by Tiago Salem Herrmann)

1240. By Tiago Salem Herrmann on 2017-02-02

Allow leave single channel by properties

1239. By Tiago Salem Herrmann on 2017-02-02

merge trunk

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-02-03 19:26:41 +0000
+++ CMakeLists.txt	2017-02-03 19:26:41 +0000
@@ -71,6 +71,8 @@
 pkg_check_modules(GST REQUIRED gstreamer-1.0)
 pkg_check_modules(FS REQUIRED farstream-0.2)
 pkg_check_modules(UBUNTU_PLATFORM_API ubuntu-platform-api)
+pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
+pkg_check_modules(PULSEAUDIO libpulse)
 
 add_definitions(-DQT_NO_KEYWORDS)
 

=== modified file 'debian/control'
--- debian/control	2017-02-03 19:26:41 +0000
+++ debian/control	2017-02-03 19:26:41 +0000
@@ -17,6 +17,7 @@
                libtelepathy-qt5-dev,
                libubuntu-application-api-dev [i386 amd64 arm64 armhf],
                libprotobuf-dev,
+               libpulse-dev [armhf],
                pkg-config,
                python:any,
                qml-module-qttest,

=== modified file 'handler/CMakeLists.txt'
--- handler/CMakeLists.txt	2017-02-03 19:26:41 +0000
+++ handler/CMakeLists.txt	2017-02-03 19:26:41 +0000
@@ -1,7 +1,13 @@
+if (PULSEAUDIO_FOUND)
+    add_definitions(-DUSE_PULSEAUDIO)
+    set(USE_PULSEAUDIO ON)
+    set(QPULSEAUDIOENGINE_CPP qpulseaudioengine.cpp)
+endif (PULSEAUDIO_FOUND)
 
 set(qt_SRCS
     accountproperties.cpp
     callagent.cpp
+    audioroutemanager.cpp
     callhandler.cpp
     chatstartingjob.cpp
     farstreamchannel.cpp
@@ -9,7 +15,10 @@
     handlerdbus.cpp
     messagejob.cpp
     messagesendingjob.cpp
+    powerdaudiomodemediator.cpp
+    powerddbus.cpp
     texthandler.cpp
+    ${QPULSEAUDIOENGINE_CPP}
     )
 
 set(handler_SRCS main.cpp ${qt_SRCS})
@@ -24,6 +33,8 @@
     ${GST_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}/libtelephonyservice
     ${CMAKE_CURRENT_BINARY_DIR}
+    ${GSETTINGS_QT_INCLUDE_DIRS}
+    ${PULSEAUDIO_INCLUDE_DIRS}
     )
 
 add_executable(telephony-service-handler ${handler_SRCS} ${handler_HDRS})
@@ -35,6 +46,7 @@
     ${TPFS_LIBRARIES}
     ${FS_LIBRARIES}
     telephonyservice
+    ${PULSEAUDIO_LIBRARIES}
     )
 
 enable_coverage(telephony-service-handler)

=== modified file 'handler/Handler.xml'
--- handler/Handler.xml	2017-02-03 19:26:41 +0000
+++ handler/Handler.xml	2017-02-03 19:26:41 +0000
@@ -114,13 +114,6 @@
             <arg name="objectPath" type="s" direction="in"/>
             <arg name="muted" type="b" direction="in"/>
         </method>
-        <method name="SetActiveAudioOutput">
-            <dox:d><![CDATA[
-                Change the current active audio output
-            ]]></dox:d>
-            <arg name="objectPath" type="s" direction="in"/>
-            <arg name="id" type="s" direction="in"/>
-        </method>
         <method name="SendDTMF">
             <dox:d><![CDATA[
                 Send a DTMF to the given channel
@@ -256,5 +249,28 @@
             <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="ProtocolList"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="ProtocolList"/>
         </signal>
+        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="true"/>
+        <property name="ActiveAudioOutput" type="s" access="readwrite"/>
+        <signal name="ActiveAudioOutputChanged">
+            <dox:d><![CDATA[
+                The active audio output has changed
+            ]]></dox:d>
+            <arg name="id" type="s"/>
+        </signal>
+        <method name="AudioOutputs">
+            <dox:d><![CDATA[
+            ]]></dox:d>
+            <arg name="outputs" type="a(sss)" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="AudioOutputDBusList"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="AudioOutputDBusList"/>
+        </method>
+        <signal name="AudioOutputsChanged">
+            <dox:d><![CDATA[
+                The available audio outputs have changed
+            ]]></dox:d>
+            <arg name="outputs" type="a(sss)"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="AudioOutputDBusList"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="AudioOutputDBusList"/>
+        </signal>
     </interface>
 </node>

=== added file 'handler/audioroutemanager.cpp'
--- handler/audioroutemanager.cpp	1970-01-01 00:00:00 +0000
+++ handler/audioroutemanager.cpp	2017-02-03 19:26:41 +0000
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[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 "audioroutemanager.h"
+#include "telepathyhelper.h"
+#include "accountentry.h"
+#include <TelepathyQt/Contact>
+#include <TelepathyQt/Functors>
+
+
+static void enable_earpiece()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallActive, AudioModeBtOrWiredOrEarpiece);
+#endif
+}
+
+static void enable_normal()
+{
+#ifdef USE_PULSEAUDIO
+    QTimer* timer = new QTimer();
+    timer->setSingleShot(true);
+    QObject::connect(timer, &QTimer::timeout, [=](){
+        QPulseAudioEngine::instance()->setMicMute(false);
+        QPulseAudioEngine::instance()->setCallMode(CallEnded, AudioModeWiredOrSpeaker);
+        timer->deleteLater();
+    });
+    timer->start(2000);
+#endif
+}
+
+static void enable_speaker()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallActive, AudioModeSpeaker);
+#endif
+}
+
+static void enable_ringtone()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallRinging, AudioModeBtOrWiredOrSpeaker);
+#endif
+}
+
+AudioRouteManager *AudioRouteManager::instance()
+{
+    static AudioRouteManager *self = new AudioRouteManager();
+    return self;
+}
+
+AudioRouteManager::AudioRouteManager(QObject *parent) :
+    QObject(parent), mAudioModeMediator(mPowerDDBus)
+{
+    TelepathyHelper::instance()->registerChannelObserver("TelephonyServiceHandlerAudioRouteManager");
+
+    QObject::connect(TelepathyHelper::instance()->channelObserver(), SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
+                 this, SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
+
+#ifdef USE_PULSEAUDIO
+    // update audio modes
+    QObject::connect(QPulseAudioEngine::instance(), SIGNAL(audioModeChanged(AudioMode)), SLOT(onAudioModeChanged(AudioMode)));
+    QObject::connect(QPulseAudioEngine::instance(), SIGNAL(availableAudioModesChanged(AudioModes)), SLOT(onAvailableAudioModesChanged(AudioModes)));
+
+    // check if we should indeed use pulseaudio
+    QByteArray pulseAudioDisabled = qgetenv("PA_DISABLED");
+    mHasPulseAudio = true;
+    if (!pulseAudioDisabled.isEmpty())
+        mHasPulseAudio = false;
+#endif
+
+    connect(this, &AudioRouteManager::activeAudioOutputChanged, Tp::memFun(&mAudioModeMediator, &PowerDAudioModeMediator::audioModeChanged));
+    connect(this, &AudioRouteManager::lastChannelClosed, Tp::memFun(&mAudioModeMediator, &PowerDAudioModeMediator::audioOutputClosed));
+}
+
+void AudioRouteManager::onCallChannelAvailable(Tp::CallChannelPtr callChannel)
+{
+    connect(callChannel.data(),
+                SIGNAL(callStateChanged(Tp::CallState)),
+                SLOT(onCallStateChanged(Tp::CallState)));
+
+    mChannels.append(callChannel);
+    updateAudioRoute(true);
+}
+
+void AudioRouteManager::onCallStateChanged(Tp::CallState state)
+{
+    Tp::CallChannelPtr channel(qobject_cast<Tp::CallChannel*>(sender()));
+    if (!channel) {
+        return;
+    }
+
+    if (channel->callState() ==  Tp::CallStateEnded) {
+        mChannels.removeOne(channel);
+    }
+    updateAudioRoute(false);
+}
+
+void AudioRouteManager::setActiveAudioOutput(const QString &id)
+{
+#ifdef USE_PULSEAUDIO
+    // fallback to earpiece/headset
+    AudioMode mode = AudioModeWiredOrEarpiece;
+    if (id == "bluetooth") {
+        mode = AudioModeBluetooth;
+    } else if (id == "speaker") {
+        mode = AudioModeSpeaker;
+    }
+    if (mHasPulseAudio)
+        QPulseAudioEngine::instance()->setCallMode(CallActive, mode);
+#endif
+}
+
+QString AudioRouteManager::activeAudioOutput()
+{
+    return mActiveAudioOutput;
+}
+
+AudioOutputDBusList AudioRouteManager::audioOutputs() const
+{
+    return mAudioOutputs;
+}
+
+void AudioRouteManager::updateAudioRoute(bool newCall)
+{
+#ifdef USE_PULSEAUDIO
+    if (!mHasPulseAudio)
+        return;
+#endif
+
+    int currentCalls = mChannels.size();
+    if (currentCalls != 0) {
+        if (currentCalls == 1) {
+            // if we have only one call, check if it's incoming and
+            // enable speaker mode so the ringtone is audible
+            Tp::CallChannelPtr callChannel = mChannels.first();
+            AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
+            if (!accountEntry || !callChannel) {
+                return;
+            }
+
+            bool incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+            Tp::CallState state = callChannel->callState();
+            if (incoming && newCall) {
+                enable_ringtone();
+                return;
+            }
+            if (state == Tp::CallStateEnded) {
+                enable_normal();
+                return;
+            }
+            // if only one call and dialing, or incoming call just accepted, then default to earpiece
+            if (newCall || (state == Tp::CallStateAccepted && incoming)) {
+                enable_earpiece();
+                return;
+            }
+        }
+    } else {
+        enable_normal();
+        Q_EMIT lastChannelClosed();
+    }
+}
+
+#ifdef USE_PULSEAUDIO
+void AudioRouteManager::onAudioModeChanged(AudioMode mode)
+{
+    qDebug("PulseAudio audio mode changed: 0x%x", mode);
+
+    if (mode == AudioModeEarpiece && mActiveAudioOutput != "earpiece") {
+        mActiveAudioOutput = "earpiece";
+    } else if (mode == AudioModeWiredHeadset && mActiveAudioOutput != "wired_headset") {
+        mActiveAudioOutput = "wired_headset";
+    } else if (mode == AudioModeSpeaker && mActiveAudioOutput != "speaker") {
+        mActiveAudioOutput = "speaker";
+    } else if (mode == AudioModeBluetooth && mActiveAudioOutput != "bluetooth") {
+        mActiveAudioOutput = "bluetooth";
+    }
+    Q_EMIT activeAudioOutputChanged(mActiveAudioOutput);
+}
+
+void AudioRouteManager::onAvailableAudioModesChanged(AudioModes modes)
+{
+    qDebug("PulseAudio available audio modes changed");
+    bool defaultFound = false;
+    mAudioOutputs.clear();
+    Q_FOREACH(const AudioMode &mode, modes) {
+        AudioOutputDBus output;
+        if (mode == AudioModeBluetooth) {
+            // there can be only one bluetooth
+            output.id = "bluetooth";
+            output.type = "bluetooth";
+            // we dont support names for now, so we set a default value
+            output.name = "bluetooth";
+        } else if (mode == AudioModeEarpiece || mode == AudioModeWiredHeadset) {
+            if (!defaultFound) {
+                defaultFound = true;
+                output.id = "default";
+                output.type = "default";
+                output.name = "default";
+            } else {
+                continue;
+            }
+        } else if (mode == AudioModeSpeaker) {
+            output.id = "speaker";
+            output.type = "speaker";
+            output.name = "speaker";
+        }
+        mAudioOutputs << output;
+    }
+    Q_EMIT audioOutputsChanged(mAudioOutputs);
+}
+#endif
+

=== added file 'handler/audioroutemanager.h'
--- handler/audioroutemanager.h	1970-01-01 00:00:00 +0000
+++ handler/audioroutemanager.h	2017-02-03 19:26:41 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[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 AUDIOROUTEMANAGER_H
+#define AUDIOROUTEMANAGER_H
+
+#ifdef USE_PULSEAUDIO
+#include "qpulseaudioengine.h"
+#endif
+#include "audiooutput.h"
+#include "powerdaudiomodemediator.h"
+#include "powerddbus.h"
+#include <QObject>
+#include <TelepathyQt/CallChannel>
+
+
+class AudioRouteManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    static AudioRouteManager *instance();
+    void setActiveAudioOutput(const QString &id);
+    QString activeAudioOutput();
+    AudioOutputDBusList audioOutputs() const;
+    void updateAudioRoute(bool newCall = false);
+
+public Q_SLOTS:
+    void onCallChannelAvailable(Tp::CallChannelPtr callChannel);
+
+Q_SIGNALS:
+    void audioOutputsChanged(const AudioOutputDBusList &outputs);
+    void activeAudioOutputChanged(const QString &id);
+    void lastChannelClosed();
+
+protected Q_SLOTS:
+    void onCallStateChanged(Tp::CallState state);
+
+private Q_SLOTS:
+#ifdef USE_PULSEAUDIO
+    void onAudioModeChanged(AudioMode mode);
+    void onAvailableAudioModesChanged(AudioModes modes);
+#endif
+
+private:
+    explicit AudioRouteManager(QObject *parent = 0);
+    QList<Tp::CallChannelPtr> mChannels;
+    AudioOutputDBusList mAudioOutputs;
+    QString mActiveAudioOutput;
+    PowerDDBus mPowerDDBus;
+    PowerDAudioModeMediator mAudioModeMediator;
+#ifdef USE_PULSEAUDIO
+    bool mHasPulseAudio;
+#endif
+};
+
+#endif // AUDIOROUTEMANAGER_H

=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2017-02-03 19:26:41 +0000
+++ handler/callhandler.cpp	2017-02-03 19:26:41 +0000
@@ -175,14 +175,6 @@
     }
 }
 
-void CallHandler::setActiveAudioOutput(const QString &objectPath, const QString &id)
-{
-    Tp::CallChannelPtr channel = callFromObjectPath(objectPath);
-
-    QDBusInterface audioOutputsInterface(channel->busName(), channel->objectPath(), CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
-    audioOutputsInterface.call("SetActiveAudioOutput", id);
-}
-
 void CallHandler::sendDTMF(const QString &objectPath, const QString &key)
 {
     /*
@@ -280,9 +272,6 @@
 void CallHandler::onCallChannelAvailable(Tp::CallChannelPtr channel)
 {
     QDBusInterface callChannelIface(channel->busName(), channel->objectPath(), DBUS_PROPERTIES_IFACE);
-    QDBusMessage reply = callChannelIface.call("GetAll", CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
-    QVariantList args = reply.arguments();
-    QMap<QString, QVariant> map = qdbus_cast<QMap<QString, QVariant> >(args[0]);
     channel->setProperty("timestamp", QDateTime::currentDateTimeUtc());
 
     if (channel->callState() == Tp::CallStateActive) {

=== modified file 'handler/callhandler.h'
--- handler/callhandler.h	2017-02-03 19:26:41 +0000
+++ handler/callhandler.h	2017-02-03 19:26:41 +0000
@@ -45,7 +45,6 @@
     void hangUpCall(const QString &objectPath);
     void setHold(const QString &objectPath, bool hold);
     void setMuted(const QString &objectPath, bool muted);
-    void setActiveAudioOutput(const QString &objectPath, const QString &id);
     void sendDTMF(const QString &objectPath, const QString &key);
 
     // conference call related

=== modified file 'handler/handlerdbus.cpp'
--- handler/handlerdbus.cpp	2017-02-03 19:26:41 +0000
+++ handler/handlerdbus.cpp	2017-02-03 19:26:41 +0000
@@ -22,6 +22,8 @@
  */
 
 #include "accountproperties.h"
+#include "audiooutput.h"
+#include "audioroutemanager.h"
 #include "callhandler.h"
 #include "handlerdbus.h"
 #include "handleradaptor.h"
@@ -54,6 +56,14 @@
             &ProtocolManager::protocolsChanged, [this]() {
                 Q_EMIT ProtocolsChanged(ProtocolManager::instance()->protocols().dbusType());
             });
+    connect(AudioRouteManager::instance(),
+            SIGNAL(audioOutputsChanged(AudioOutputDBusList)),
+            SIGNAL(AudioOutputsChanged(AudioOutputDBusList)));
+    connect(AudioRouteManager::instance(),
+            SIGNAL(activeAudioOutputChanged(QString)),
+            SIGNAL(ActiveAudioOutputChanged(QString)));
+
+>>>>>>> MERGE-SOURCE
 }
 
 HandlerDBus::~HandlerDBus()
@@ -161,6 +171,21 @@
     return TextHandler::instance()->changeRoomTitle(objectPath, title);
 }
 
+void HandlerDBus::setActiveAudioOutput(const QString &id)
+{
+    AudioRouteManager::instance()->setActiveAudioOutput(id);
+}
+
+QString HandlerDBus::activeAudioOutput() const
+{
+    return AudioRouteManager::instance()->activeAudioOutput();
+}
+
+AudioOutputDBusList HandlerDBus::AudioOutputs() const
+{
+    return AudioRouteManager::instance()->audioOutputs();
+}
+
 bool HandlerDBus::connectToBus()
 {
     new TelephonyServiceHandlerAdaptor(this);
@@ -208,11 +233,6 @@
     CallHandler::instance()->setMuted(objectPath, muted);
 }
 
-void HandlerDBus::SetActiveAudioOutput(const QString &objectPath, const QString &id)
-{
-    CallHandler::instance()->setActiveAudioOutput(objectPath, id);
-}
-
 void HandlerDBus::SendDTMF(const QString &objectPath, const QString &key)
 {
     CallHandler::instance()->sendDTMF(objectPath, key);

=== modified file 'handler/handlerdbus.h'
--- handler/handlerdbus.h	2017-02-03 19:26:41 +0000
+++ handler/handlerdbus.h	2017-02-03 19:26:41 +0000
@@ -28,6 +28,7 @@
 #include <QtDBus/QDBusContext>
 #include "chatmanager.h"
 #include "dbustypes.h"
+#include "audiooutput.h"
 
 typedef QMap<QString,QVariantMap> AllAccountsProperties;
 
@@ -42,6 +43,11 @@
                WRITE setCallIndicatorVisible
                NOTIFY CallIndicatorVisibleChanged)
 
+    Q_PROPERTY(QString ActiveAudioOutput
+               READ activeAudioOutput
+               WRITE setActiveAudioOutput
+               NOTIFY ActiveAudioOutputChanged)
+
 public:
     HandlerDBus(QObject* parent=0);
     ~HandlerDBus();
@@ -62,6 +68,8 @@
     void unregisterObject(const QString &path);
 
     static HandlerDBus *instance();
+    QString activeAudioOutput() const;
+    void setActiveAudioOutput(const QString &id);
 
 public Q_SLOTS:
     bool connectToBus();
@@ -83,13 +91,13 @@
     Q_NOREPLY void HangUpCall(const QString &objectPath);
     Q_NOREPLY void SetHold(const QString &objectPath, bool hold);
     Q_NOREPLY void SetMuted(const QString &objectPath, bool muted);
-    Q_NOREPLY void SetActiveAudioOutput(const QString &objectPath, const QString &id);
     Q_NOREPLY void SendDTMF(const QString &objectPath, const QString &key);
 
     // conference call related
     Q_NOREPLY void CreateConferenceCall(const QStringList &objectPaths);
     Q_NOREPLY void MergeCall(const QString &conferenceObjectPath, const QString &callObjectPath);
     Q_NOREPLY void SplitCall(const QString &objectPath);
+    AudioOutputDBusList AudioOutputs() const;
 
 
 
@@ -101,6 +109,8 @@
     void ConferenceCallRequestFinished(bool succeeded);
     void CallHoldingFailed(const QString &objectPath);
     void ProtocolsChanged(const ProtocolList &protocols);
+    void ActiveAudioOutputChanged(const QString &id);
+    void AudioOutputsChanged(const AudioOutputDBusList &audioOutputs);
 
 private:
     bool mCallIndicatorVisible;

=== modified file 'handler/main.cpp'
--- handler/main.cpp	2017-02-03 19:26:41 +0000
+++ handler/main.cpp	2017-02-03 19:26:41 +0000
@@ -31,6 +31,9 @@
 #include <TelepathyQt/AccountManager>
 #include <TelepathyQt/Contact>
 #include <telepathy-farstream/telepathy-farstream.h>
+#include <TelepathyQt/CallChannel>
+
+Q_DECLARE_METATYPE(Tp::CallChannelPtr)
 
 int main(int argc, char **argv)
 {
@@ -39,6 +42,12 @@
 
     Tp::registerTypes();
     gst_init(&argc, &argv);
+    qRegisterMetaType<Tp::CallChannelPtr>();
+    qRegisterMetaType<AudioOutputDBus>();
+    qRegisterMetaType<AudioOutputDBusList>();
+
+    qDBusRegisterMetaType<AudioOutputDBus>();
+    qDBusRegisterMetaType<AudioOutputDBusList>();
 
     // check if there is already an instance of the handler running
     if (ApplicationUtils::checkApplicationRunning(TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler")) {
@@ -46,11 +55,13 @@
         return 1;
     }
 
+    HandlerDBus dbus;
     Handler *handler = new Handler();
-    QObject::connect(TelepathyHelper::instance(), &TelepathyHelper::setupReady, [handler]() {
+    QObject::connect(TelepathyHelper::instance(), &TelepathyHelper::setupReady, [&]() {
         TelepathyHelper::instance()->registerClient(handler, "TelephonyServiceHandler");
+        dbus.connectToBus();
     });
- 
+
     QObject::connect(handler, SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
                      CallHandler::instance(), SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
     QObject::connect(handler, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
@@ -59,5 +70,8 @@
     QObject::connect(TelepathyHelper::instance(), SIGNAL(setupReady()),
                      HandlerDBus::instance(), SLOT(connectToBus()));
 
+    // instanciate the display name settings singleton, it will work by itself
+    DisplayNameSettings::instance();
+
     return app.exec();
 }

=== added file 'handler/powerd.h'
--- handler/powerd.h	1970-01-01 00:00:00 +0000
+++ handler/powerd.h	2017-02-03 19:26:41 +0000
@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef POWERD_H
+#define POWERD_H
+
+class PowerD
+{
+public:
+    PowerD() = default;
+    virtual ~PowerD() = default;
+    PowerD(PowerD const&) = delete;
+    PowerD& operator=(PowerD const&) = delete;
+
+    virtual void enableProximityHandling() = 0;
+    virtual void disableProximityHandling() = 0;
+};
+
+#endif // POWERD_H

=== added file 'handler/powerdaudiomodemediator.cpp'
--- handler/powerdaudiomodemediator.cpp	1970-01-01 00:00:00 +0000
+++ handler/powerdaudiomodemediator.cpp	2017-02-03 19:26:41 +0000
@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#include <QDBusInterface>
+#include "powerdaudiomodemediator.h"
+
+PowerDAudioModeMediator::PowerDAudioModeMediator(PowerD &powerd)
+    : powerd(powerd)
+{
+}
+
+void PowerDAudioModeMediator::audioModeChanged(const QString &mode)
+{
+    bool enableProximity = !(mode == "speaker" || mode == "bluetooth" || mode == "wired_headset");
+
+    if (mProximityEnabled != enableProximity)
+    {
+        mProximityEnabled = enableProximity;
+        apply();
+    }
+}
+
+void PowerDAudioModeMediator::apply() const
+{
+    if (mProximityEnabled) {
+        powerd.enableProximityHandling();
+    } else {
+        // we need to power the screen on before disabling the proximity handling
+        QDBusInterface unityIface("com.canonical.Unity.Screen",
+                                  "/com/canonical/Unity/Screen",
+                                  "com.canonical.Unity.Screen",
+                                  QDBusConnection::systemBus());
+        QList<QVariant> args;
+        args.append("on");
+        args.append(3);
+        unityIface.callWithArgumentList(QDBus::NoBlock, "setScreenPowerMode", args);
+        powerd.disableProximityHandling();
+    }
+}
+
+void PowerDAudioModeMediator::audioOutputClosed()
+{
+    if (mProximityEnabled)
+    {
+        mProximityEnabled = false;
+        apply();
+    }
+}

=== added file 'handler/powerdaudiomodemediator.h'
--- handler/powerdaudiomodemediator.h	1970-01-01 00:00:00 +0000
+++ handler/powerdaudiomodemediator.h	2017-02-03 19:26:41 +0000
@@ -0,0 +1,46 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd.
+**
+** Authors:
+**  Andreas Pokorny <[e-mail]>
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#ifndef POWERDAUDIOMODEMEDIATOR_H
+#define POWERDAUDIOMODEMEDIATOR_H
+
+#include "powerd.h"
+
+#include <QString>
+#include <fstream>
+#include <memory>
+
+class PowerD;
+/*!
+ * \brief PowerDAudioModeMediator is responsible for configuring proximity
+ * handling of powerd during different call states and used audio outputs.
+ * In General that mean enabling sreen blanking on proximity events, when
+ * a call is active and neither a bluetooth headset nor the speakers are used.
+ */
+class PowerDAudioModeMediator
+{
+public:
+    PowerDAudioModeMediator(PowerD &powerd);
+    void audioModeChanged(const QString &mode);
+    void audioOutputClosed();
+private:
+    void apply() const;
+    PowerD &powerd;
+    bool mProximityEnabled{false};
+};
+
+#endif

=== added file 'handler/powerddbus.cpp'
--- handler/powerddbus.cpp	1970-01-01 00:00:00 +0000
+++ handler/powerddbus.cpp	2017-02-03 19:26:41 +0000
@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#include "powerddbus.h"
+
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+
+PowerDDBus::PowerDDBus()
+    : mPowerDIface{
+        new QDBusInterface(
+            "com.canonical.powerd",
+            "/com/canonical/powerd",
+            "com.canonical.powerd",
+            QDBusConnection::systemBus())}
+{
+}
+
+void PowerDDBus::enableProximityHandling()
+{
+    mPowerDIface->call("enableProximityHandling", "telephony-service-handler");
+}
+
+void PowerDDBus::disableProximityHandling()
+{
+    mPowerDIface->call("disableProximityHandling", "telephony-service-handler");
+}

=== added file 'handler/powerddbus.h'
--- handler/powerddbus.h	1970-01-01 00:00:00 +0000
+++ handler/powerddbus.h	2017-02-03 19:26:41 +0000
@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef POWERD_DUBS_H
+#define POWERD_DBUS_H
+
+#include "powerd.h"
+
+#include <memory>
+
+class QDBusInterface;
+
+class PowerDDBus : public PowerD
+{
+public:
+    PowerDDBus();
+    void enableProximityHandling() override;
+    void disableProximityHandling() override;
+private:
+    std::unique_ptr<QDBusInterface> mPowerDIface;
+};
+
+#endif

=== added file 'handler/qpulseaudioengine.cpp'
--- handler/qpulseaudioengine.cpp	1970-01-01 00:00:00 +0000
+++ handler/qpulseaudioengine.cpp	2017-02-03 19:26:41 +0000
@@ -0,0 +1,853 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file was taken from qt5 and modified by 
+** David Henningsson <[e-mail]> for usage in 
+** telepathy-ofono.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#include <QtCore/qdebug.h>
+
+#include "qpulseaudioengine.h"
+#include <sys/types.h>
+#include <unistd.h>
+
+#define PULSEAUDIO_PROFILE_HSP "headset_head_unit"
+#define PULSEAUDIO_PROFILE_A2DP "a2dp_sink"
+
+QT_BEGIN_NAMESPACE
+
+static void contextStateCallbackInit(pa_context *context, void *userdata)
+{
+    Q_UNUSED(context);
+    QPulseAudioEngineWorker *pulseEngine = reinterpret_cast<QPulseAudioEngineWorker*>(userdata);
+    pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+}
+
+static void contextStateCallback(pa_context *context, void *userdata)
+{
+    Q_UNUSED(userdata);
+    Q_UNUSED(context);
+}
+
+static void success_cb(pa_context *context, int success, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = reinterpret_cast<QPulseAudioEngineWorker*>(userdata);
+    pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+}
+
+/* Callbacks used when handling events from PulseAudio */
+static void plug_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->plugCardCallback(info);
+}
+
+static void update_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->updateCardCallback(info);
+}
+
+static void unplug_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (!pulseEngine) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+
+    if (info == NULL) {
+        /* That means that the card used to query card_info was removed */
+        pulseEngine->unplugCardCallback();
+    }
+}
+
+static void subscribeCallback(pa_context *context, pa_subscription_event_type_t t, uint32_t idx, void *userdata)
+{
+    /* For card change events (slot plug/unplug and add/remove card) */
+    if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CARD) {
+        if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_CHANGE) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_CHANGE), Q_ARG(unsigned int, idx));
+        } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_NEW), Q_ARG(unsigned int, idx));
+        } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_REMOVE), Q_ARG(unsigned int, idx));
+        }
+    }
+}
+
+QPulseAudioEngineWorker::QPulseAudioEngineWorker(QObject *parent)
+    : QObject(parent)
+    , m_mainLoopApi(0)
+    , m_context(0)
+    , m_callstatus(CallEnded)
+    , m_audiomode(AudioModeSpeaker)
+    , m_micmute(false)
+    , m_defaultsink("sink.primary")
+    , m_defaultsource("source.primary")
+    , m_voicecallcard("")
+    , m_voicecallhighest("")
+    , m_voicecallprofile("")
+    , m_bt_hsp("")
+    , m_bt_hsp_a2dp("")
+    , m_default_bt_card_fallback("")
+
+{
+    m_mainLoop = pa_threaded_mainloop_new();
+    if (m_mainLoop == 0) {
+        qWarning("Unable to create pulseaudio mainloop");
+        return;
+    }
+
+    if (pa_threaded_mainloop_start(m_mainLoop) != 0) {
+        qWarning("Unable to start pulseaudio mainloop");
+        pa_threaded_mainloop_free(m_mainLoop);
+        m_mainLoop = 0;
+        return;
+    }
+
+    createPulseContext();
+}
+
+bool QPulseAudioEngineWorker::createPulseContext()
+{
+    bool keepGoing = true;
+    bool ok = true;
+
+    if (m_context)
+        return true;
+
+    m_mainLoopApi = pa_threaded_mainloop_get_api(m_mainLoop);
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    m_context = pa_context_new(m_mainLoopApi, QString(QLatin1String("QtmPulseContext:%1")).arg(::getpid()).toLatin1().constData());
+    pa_context_set_state_callback(m_context, contextStateCallbackInit, this);
+
+    if (!m_context) {
+        qWarning("Unable to create new pulseaudio context");
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        return false;
+    }
+
+    if (pa_context_connect(m_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) {
+        qWarning("Unable to create a connection to the pulseaudio context");
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        releasePulseContext();
+        return false;
+    }
+
+    pa_threaded_mainloop_wait(m_mainLoop);
+
+    while (keepGoing) {
+        switch (pa_context_get_state(m_context)) {
+            case PA_CONTEXT_CONNECTING:
+            case PA_CONTEXT_AUTHORIZING:
+            case PA_CONTEXT_SETTING_NAME:
+                break;
+
+            case PA_CONTEXT_READY:
+                qDebug("Pulseaudio connection established.");
+                keepGoing = false;
+                break;
+
+            case PA_CONTEXT_TERMINATED:
+                qCritical("Pulseaudio context terminated.");
+                keepGoing = false;
+                ok = false;
+                break;
+
+            case PA_CONTEXT_FAILED:
+            default:
+                qCritical() << QString("Pulseaudio connection failure: %1").arg(pa_strerror(pa_context_errno(m_context)));
+                keepGoing = false;
+                ok = false;
+        }
+
+        if (keepGoing) {
+            pa_threaded_mainloop_wait(m_mainLoop);
+        }
+    }
+
+    if (ok) {
+        pa_context_set_state_callback(m_context, contextStateCallback, this);
+        pa_context_set_subscribe_callback(m_context, subscribeCallback, this);
+        pa_context_subscribe(m_context, PA_SUBSCRIPTION_MASK_CARD, NULL, this);
+    } else {
+        if (m_context) {
+            pa_context_unref(m_context);
+            m_context = 0;
+        }
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+    return true;
+}
+
+
+void QPulseAudioEngineWorker::releasePulseContext()
+{
+    if (m_context) {
+        pa_threaded_mainloop_lock(m_mainLoop);
+        pa_context_disconnect(m_context);
+        pa_context_unref(m_context);
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        m_context = 0;
+    }
+
+}
+
+QPulseAudioEngineWorker::~QPulseAudioEngineWorker()
+{
+    releasePulseContext();
+
+    if (m_mainLoop) {
+        pa_threaded_mainloop_stop(m_mainLoop);
+        pa_threaded_mainloop_free(m_mainLoop);
+        m_mainLoop = 0;
+    }
+}
+
+void QPulseAudioEngineWorker::cardInfoCallback(const pa_card_info *info)
+{
+    pa_card_profile_info2 *voice_call = NULL, *highest = NULL;
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+
+    /* For now we only support one card with the voicecall feature */
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!highest || info->profiles2[i]->priority > highest->priority)
+            highest = info->profiles2[i];
+        if (!strcmp(info->profiles2[i]->name, "voicecall"))
+            voice_call = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP) &&
+                 info->profiles2[i]->available != 0)
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) &&
+                 info->profiles2[i]->available != 0)
+            a2dp = info->profiles2[i];
+    }
+
+    /* Record the card that supports voicecall (default one to be used) */
+    if (voice_call) {
+        qDebug("Found card that supports voicecall: '%s'", info->name);
+        m_voicecallcard = info->name;
+        m_voicecallhighest = highest->name;
+    qDebug("1");
+        m_voicecallprofile = voice_call->name;
+    qDebug("2");
+    }
+
+    /* Handle the use cases needed for bluetooth */
+    if (hsp && a2dp) {
+        qDebug("Found card that supports hsp and a2dp: '%s'", info->name);
+        m_bt_hsp_a2dp = info->name;
+    } else if (hsp && (a2dp == NULL)) {
+        /* This card only provides the hsp profile */
+        qDebug("Found card that supports only hsp: '%s'", info->name);
+        m_bt_hsp = info->name;
+    }
+    qDebug("3");
+}
+
+void QPulseAudioEngineWorker::sinkInfoCallback(const pa_sink_info *info)
+{
+    pa_sink_port_info *earpiece = NULL, *speaker = NULL;
+    pa_sink_port_info *wired_headset = NULL, *wired_headphone = NULL;
+    pa_sink_port_info *preferred = NULL;
+    pa_sink_port_info *bluetooth_sco = NULL;
+    pa_sink_port_info *speaker_and_wired_headphone = NULL;
+    AudioMode audiomodetoset;
+    AudioModes modes;
+
+    for (int i = 0; i < info->n_ports; i++) {
+        if (!strcmp(info->ports[i]->name, "output-earpiece"))
+            earpiece = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-wired_headset") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headset = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-wired_headphone") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headphone = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-speaker"))
+            speaker = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-bluetooth_sco"))
+            bluetooth_sco = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-speaker+wired_headphone"))
+            speaker_and_wired_headphone = info->ports[i];
+    }
+
+    if (!earpiece || !speaker)
+        return; /* Not the right sink */
+
+    /* Refresh list of available audio modes */
+    modes.append(AudioModeEarpiece);
+    modes.append(AudioModeSpeaker);
+    if (wired_headset || wired_headphone)
+        modes.append(AudioModeWiredHeadset);
+    if (bluetooth_sco && ((m_bt_hsp != "") || (m_bt_hsp_a2dp != "")))
+        modes.append(AudioModeBluetooth);
+
+    /* Check if the requested mode is available (earpiece*/
+    if (((m_audiomode == AudioModeWiredHeadset) && !modes.contains(AudioModeWiredHeadset)) ||
+            ((m_audiomode == AudioModeBluetooth) && !modes.contains(AudioModeBluetooth)))
+        return;
+
+    /* Now to decide which output to be used, depending on the active mode */
+    if (m_audiomode & AudioModeEarpiece) {
+        preferred = earpiece;
+        audiomodetoset = AudioModeEarpiece;
+    }
+    if (m_audiomode & AudioModeSpeaker) {
+        preferred = speaker;
+        audiomodetoset = AudioModeSpeaker;
+    }
+    if ((m_audiomode & AudioModeWiredHeadset) && (modes.contains(AudioModeWiredHeadset))) {
+        preferred = wired_headset ? wired_headset : wired_headphone;
+        audiomodetoset = AudioModeWiredHeadset;
+    }
+    if (m_callstatus == CallRinging && speaker_and_wired_headphone) {
+        preferred = speaker_and_wired_headphone;
+    }
+    if ((m_audiomode & AudioModeBluetooth) && (modes.contains(AudioModeBluetooth))) {
+        preferred = bluetooth_sco;
+        audiomodetoset = AudioModeBluetooth;
+    }
+
+    m_audiomode = audiomodetoset;
+
+    m_nametoset = info->name;
+    if (info->active_port != preferred)
+        m_valuetoset = preferred->name;
+
+    if (modes != m_availableAudioModes)
+        m_availableAudioModes = modes;
+}
+
+void QPulseAudioEngineWorker::sourceInfoCallback(const pa_source_info *info)
+{
+    pa_source_port_info *builtin_mic = NULL, *preferred = NULL;
+    pa_source_port_info *wired_headset = NULL, *bluetooth_sco = NULL;
+
+    if (info->monitor_of_sink != PA_INVALID_INDEX)
+        return;  /* Not the right source */
+
+    for (int i = 0; i < info->n_ports; i++) {
+        if (!strcmp(info->ports[i]->name, "input-builtin_mic"))
+            builtin_mic = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "input-wired_headset") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headset = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "input-bluetooth_sco_headset"))
+            bluetooth_sco = info->ports[i];
+    }
+
+    if (!builtin_mic)
+        return; /* Not the right source */
+
+    /* Now to decide which output to be used, depending on the active mode */
+    if ((m_audiomode & AudioModeEarpiece) || (m_audiomode & AudioModeSpeaker))
+        preferred = builtin_mic;
+    if ((m_audiomode & AudioModeWiredHeadset) && (m_availableAudioModes.contains(AudioModeWiredHeadset)))
+        preferred = wired_headset ? wired_headset : builtin_mic;
+    if ((m_audiomode & AudioModeBluetooth) && (m_availableAudioModes.contains(AudioModeBluetooth)))
+        preferred = bluetooth_sco;
+
+    m_nametoset = info->name;
+    if (info->active_port != preferred)
+        m_valuetoset = preferred->name;
+}
+
+void QPulseAudioEngineWorker::serverInfoCallback(const pa_server_info *info)
+{
+    /* Saving default sink/source to restore after call hangup */
+    m_defaultsink = info->default_sink_name;
+    m_defaultsource = info->default_source_name;
+
+    /* In the case of a server callback we need to signal the mainloop */
+    pa_threaded_mainloop_signal(mainloop(), 0);
+}
+
+static void cardinfo_cb(pa_context *context, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->cardInfoCallback(info);
+}
+
+static void sinkinfo_cb(pa_context *context, const pa_sink_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->sinkInfoCallback(info);
+}
+
+static void sourceinfo_cb(pa_context *context, const pa_source_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->sourceInfoCallback(info);
+}
+
+static void serverinfo_cb(pa_context *context, const pa_server_info *info, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (!pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->serverInfoCallback(info);
+}
+
+bool QPulseAudioEngineWorker::handleOperation(pa_operation *operation, const char *func_name)
+{
+    if (!operation) {
+        qCritical("'%s' failed (lost PulseAudio connection?)", func_name);
+        /* Free resources so it can retry a new connection during next operation */
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        releasePulseContext();
+        return false;
+    }
+
+    while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING)
+        pa_threaded_mainloop_wait(m_mainLoop);
+    pa_operation_unref(operation);
+    return true;
+}
+
+int QPulseAudioEngineWorker::setupVoiceCall()
+{
+    pa_operation *o;
+
+    qDebug("Setting up pulseaudio for voice call");
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* Get and set the default sink/source to be restored later */
+    o = pa_context_get_server_info(m_context, serverinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_server_info"))
+        return -1;
+
+    qDebug("Recorded default sink: %s default source: %s",
+            m_defaultsink.c_str(), m_defaultsource.c_str());
+
+    /* Walk through the list of devices, find the voice call capable card and
+     * identify if we have bluetooth capable devices (hsp and a2dp) */
+    m_voicecallcard = m_voicecallhighest = m_voicecallprofile = "";
+    m_bt_hsp = m_bt_hsp_a2dp = "";
+    o = pa_context_get_card_info_list(m_context, cardinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_card_info_list"))
+        return -1;
+    /* In case we have only one bt device that provides hsp and a2dp, we need
+     * to make sure we switch the default profile for that card (to hsp) */
+    if ((m_bt_hsp_a2dp != "") && (m_bt_hsp == "")) {
+        qDebug("Setting PulseAudio card '%s' profile '%s'",
+                m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_HSP);
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_HSP, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return -1;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+
+    return 0;
+}
+
+void QPulseAudioEngineWorker::restoreVoiceCall()
+{
+    pa_operation *o;
+
+    qDebug("Restoring pulseaudio previous state");
+
+    /* Then restore previous settings */
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* See if we need to restore any HSP+AD2P device state */
+    if ((m_bt_hsp_a2dp != "") && (m_bt_hsp == "")) {
+        qDebug("Restoring PulseAudio card '%s' to profile '%s'",
+                m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_A2DP);
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    }
+
+    /* Restore default sink/source */
+    if (m_defaultsink != "") {
+        qDebug("Restoring PulseAudio default sink to '%s'", m_defaultsink.c_str());
+        o = pa_context_set_default_sink(m_context, m_defaultsink.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_sink"))
+            return;
+    }
+    if (m_defaultsource != "") {
+        qDebug("Restoring PulseAudio default source to '%s'", m_defaultsource.c_str());
+        o = pa_context_set_default_source(m_context, m_defaultsource.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_source"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+}
+
+void QPulseAudioEngineWorker::setCallMode(CallStatus callstatus, AudioMode audiomode)
+{
+    if (!createPulseContext()) {
+       return;
+    }
+    CallStatus p_callstatus = m_callstatus;
+    AudioMode p_audiomode = m_audiomode;
+    AudioModes p_availableAudioModes = m_availableAudioModes;
+    pa_operation *o;
+
+    /* Check if we need to save the current pulseaudio state (e.g. when starting a call) */
+    if ((callstatus != CallEnded) && (p_callstatus == CallEnded)) {
+        if (setupVoiceCall() < 0) {
+            qCritical("Failed to setup PulseAudio for Voice Call");
+            return;
+        }
+    }
+
+    /* If we have an active call, update internal state (used later when updating sink/source ports) */
+    m_callstatus = callstatus;
+    m_audiomode = audiomode;
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* Switch the virtual card mode when call is active and not active
+     * This needs to be done before sink/source gets updated, because after changing mode
+     * it will automatically move to input/output-parking */
+    if ((m_callstatus == CallActive) && (p_callstatus != CallActive) &&
+            (m_voicecallcard != "") && (m_voicecallprofile != "")) {
+        qDebug("Setting PulseAudio card '%s' profile '%s'",
+                m_voicecallcard.c_str(), m_voicecallprofile.c_str());
+        o = pa_context_set_card_profile_by_name(m_context,
+                m_voicecallcard.c_str(), m_voicecallprofile.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    } else if ((m_callstatus == CallEnded) && (m_voicecallcard != "") && (m_voicecallhighest != "")) {
+        /* If using droid, make sure to restore to the profile that has the highest score */
+        qDebug("Restoring PulseAudio card '%s' to profile '%s'",
+                m_voicecallcard.c_str(), m_voicecallhighest.c_str());
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_voicecallcard.c_str(), m_voicecallhighest.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    }
+
+    /* Find highest compatible sink/source elements from the voicecall
+       compatible card (on touch this means the pulse droid element) */
+    m_nametoset = m_valuetoset = "";
+    o = pa_context_get_sink_info_list(m_context, sinkinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_sink_info_list"))
+        return;
+    if ((m_nametoset != "") && (m_nametoset != m_defaultsink)) {
+        qDebug("Setting PulseAudio default sink to '%s'", m_nametoset.c_str());
+        o = pa_context_set_default_sink(m_context, m_nametoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_sink"))
+            return;
+    }
+    if (m_valuetoset != "") {
+        qDebug("Setting PulseAudio sink '%s' port '%s'",
+                m_nametoset.c_str(), m_valuetoset.c_str());
+        o = pa_context_set_sink_port_by_name(m_context, m_nametoset.c_str(),
+                                             m_valuetoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_sink_port_by_name"))
+            return;
+    }
+
+    /* Same for source */
+    m_nametoset = m_valuetoset = "";
+    o = pa_context_get_source_info_list(m_context, sourceinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_source_info_list"))
+        return;
+    if ((m_nametoset != "") && (m_nametoset != m_defaultsource)) {
+        qDebug("Setting PulseAudio default source to '%s'", m_nametoset.c_str());
+        o = pa_context_set_default_source(m_context, m_nametoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_source"))
+            return;
+    }
+    if (m_valuetoset != "") {
+        qDebug("Setting PulseAudio source '%s' port '%s'",
+                m_nametoset.c_str(), m_valuetoset.c_str());
+        o = pa_context_set_source_port_by_name(m_context, m_nametoset.c_str(),
+                                               m_valuetoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_source_port_by_name"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+
+    /* Notify if the list of audio modes changed */
+    if (p_availableAudioModes != m_availableAudioModes)
+        Q_EMIT availableAudioModesChanged(m_availableAudioModes);
+
+    /* Notify if call mode changed */
+    if (p_audiomode != m_audiomode) {
+        Q_EMIT audioModeChanged(m_audiomode);
+    }
+
+    /* If no more active voicecall, restore previous saved pulseaudio state */
+    if (callstatus == CallEnded) {
+        restoreVoiceCall();
+    }
+
+    /* In case the app had set mute when the call wasn't active, make sure we reflect it here */
+    if (m_callstatus != CallEnded)
+        setMicMute(m_micmute);
+}
+
+void QPulseAudioEngineWorker::setMicMute(bool muted)
+{
+    if (!createPulseContext()) {
+       return;
+    }
+ 
+    m_micmute = muted;
+
+    if (m_callstatus == CallEnded)
+        return;
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    m_nametoset = "";
+    pa_operation *o = pa_context_get_source_info_list(m_context, sourceinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_source_info_list"))
+        return;
+
+    if (m_nametoset != "") {
+        int m = m_micmute ? 1 : 0;
+        qDebug("Setting PulseAudio source '%s' muted '%d'", m_nametoset.c_str(), m);
+        o = pa_context_set_source_mute_by_name(m_context, 
+            m_nametoset.c_str(), m, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_source_mute_by_name"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+}
+
+void QPulseAudioEngineWorker::plugCardCallback(const pa_card_info *info)
+{
+    qDebug("Notified about card (%s) add event from PulseAudio", info->name);
+
+    /* Check if it's indeed a BT device (with at least one hsp profile) */
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP))
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) && 
+                  info->profiles2[i]->available != 0) {
+            qDebug("Found a2dp");
+            a2dp = info->profiles2[i];
+        }
+        qDebug("%s", info->profiles2[i]->name);
+    }
+
+    if ((!info->active_profile || !strcmp(info->active_profile->name, "off")) && a2dp) {
+        qDebug("No profile set");
+        m_default_bt_card_fallback = info->name;
+    }
+
+    /* We only care about BT (HSP) devices, and if one is not already available */
+    if ((m_callstatus != CallEnded) && ((m_bt_hsp == "") || (m_bt_hsp_a2dp == ""))) {
+        if (hsp)
+            m_handleevent = true;
+    }
+}
+
+void QPulseAudioEngineWorker::updateCardCallback(const pa_card_info *info)
+{
+    qDebug("Notified about card (%s) changes event from PulseAudio", info->name);
+
+    /* Check if it's indeed a BT device (with at least one hsp profile) */
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP))
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) && 
+                  info->profiles2[i]->available != 0) {
+            qDebug("Found a2dp");
+            a2dp = info->profiles2[i];
+        }
+        qDebug("%s", info->profiles2[i]->name);
+    }
+
+    if ((!info->active_profile || !strcmp(info->active_profile->name, "off")) && a2dp) {
+        qDebug("No profile set");
+        m_default_bt_card_fallback = info->name;
+    }
+
+
+    /* We only care if the card event for the voicecall capable card */
+    if ((m_callstatus == CallActive) && (!strcmp(info->name, m_voicecallcard.c_str()))) {
+        if (m_audiomode == AudioModeWiredHeadset) {
+            /* If previous mode is wired, it means it got unplugged */
+            m_handleevent = true;
+            m_audiomodetoset = AudioModeBtOrWiredOrEarpiece;
+        } else if ((m_audiomode == AudioModeEarpiece) || ((m_audiomode == AudioModeSpeaker))) {
+            /* Now only trigger the event in case wired headset/headphone is now available */
+            pa_card_port_info *port_info = NULL;
+            for (int i = 0; i < info->n_ports; i++) {
+                if (info->ports[i] && (info->ports[i]->available == PA_PORT_AVAILABLE_YES) && (
+                            !strcmp(info->ports[i]->name, "output-wired_headset") ||
+                            !strcmp(info->ports[i]->name, "output-wired_headphone"))) {
+                    m_handleevent = true;
+                    m_audiomodetoset = AudioModeWiredOrEarpiece;
+                }
+            }
+        } else if (m_audiomode == AudioModeBluetooth) {
+            /* Handle the event so we can update the audiomodes */
+            m_handleevent = true;
+            m_audiomodetoset = AudioModeBluetooth;
+        }
+    }
+}
+
+void QPulseAudioEngineWorker::unplugCardCallback()
+{
+    if (m_callstatus != CallEnded) {
+        m_handleevent = true;
+    }
+}
+
+void QPulseAudioEngineWorker::handleCardEvent(const int evt, const unsigned int idx)
+{
+    pa_operation *o = NULL;
+
+    /* Internal state var used to know if we need to update our internal state */
+    m_handleevent = false;
+
+    if (evt == PA_SUBSCRIPTION_EVENT_NEW) {
+        o = pa_context_get_card_info_by_index(m_context, idx, plug_card_cb, this);
+        if (!handleOperation(o, "pa_context_get_card_info_by_index"))
+            return;
+
+        if (m_default_bt_card_fallback != "") {
+            o = pa_context_set_card_profile_by_name(m_context,
+                m_default_bt_card_fallback.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+            if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+                return;
+            m_default_bt_card_fallback = "";
+        }
+
+        if (m_handleevent) {
+            qDebug("Adding new BT-HSP capable device");
+            /* In case A2DP is available, switch to HSP */
+            if (setupVoiceCall() < 0)
+                return;
+            /* Enable the HSP output port  */
+            setCallMode(m_callstatus, AudioModeBluetooth);
+        }
+    } else if (evt == PA_SUBSCRIPTION_EVENT_CHANGE) {
+        o = pa_context_get_card_info_by_index(m_context, idx, update_card_cb, this);
+        if (!handleOperation(o, "pa_context_get_card_info_by_index"))
+            return;
+
+        if (m_default_bt_card_fallback != "") {
+            o = pa_context_set_card_profile_by_name(m_context,
+                m_default_bt_card_fallback.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+            if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+                return;
+            m_default_bt_card_fallback = "";
+        }
+
+        if (m_handleevent) {
+            /* In this case it means the handset state changed */
+            qDebug("Notifying card changes for the voicecall capable card");
+            setCallMode(m_callstatus, m_audiomodetoset);
+        }
+    } else if (evt == PA_SUBSCRIPTION_EVENT_REMOVE) {
+        /* Check if the main HSP card was removed */
+        if (m_bt_hsp != "") {
+            o = pa_context_get_card_info_by_name(m_context, m_bt_hsp.c_str(), unplug_card_cb, this);
+            if (!handleOperation(o, "pa_context_get_sink_info_by_name"))
+                return;
+        }
+        if (m_bt_hsp_a2dp != "") {
+            o = pa_context_get_card_info_by_name(m_context, m_bt_hsp_a2dp.c_str(), unplug_card_cb, this);
+            if (!handleOperation(o, "pa_context_get_sink_info_by_name"))
+                return;
+        }
+        if (m_handleevent) {
+            qDebug("Notifying about BT-HSP card removal");
+            /* Needed in order to save the default sink/source */
+            if (setupVoiceCall() < 0)
+                return;
+            /* Enable the default handset output port  */
+            setCallMode(m_callstatus, AudioModeWiredOrEarpiece);
+        }
+    }
+}
+
+Q_GLOBAL_STATIC(QPulseAudioEngine, pulseEngine);
+
+QPulseAudioEngine::QPulseAudioEngine(QObject *parent) :
+    QObject(parent)
+{
+    qRegisterMetaType<CallStatus>();
+    qRegisterMetaType<AudioMode>();
+    qRegisterMetaType<AudioModes>();
+    mWorker = new QPulseAudioEngineWorker();
+    QObject::connect(mWorker, SIGNAL(audioModeChanged(const AudioMode)), this, SIGNAL(audioModeChanged(const AudioMode)), Qt::QueuedConnection);
+    QObject::connect(mWorker, SIGNAL(availableAudioModesChanged(const AudioModes)), this, SIGNAL(availableAudioModesChanged(const AudioModes)), Qt::QueuedConnection);
+    mWorker->createPulseContext();
+    mWorker->moveToThread(&mThread);
+    mThread.start();
+}
+
+QPulseAudioEngine::~QPulseAudioEngine()
+{
+    mThread.quit();
+    mThread.wait();
+}
+
+QPulseAudioEngine *QPulseAudioEngine::instance()
+{
+    QPulseAudioEngine *engine = pulseEngine();
+    return engine;
+}
+
+void QPulseAudioEngine::setCallMode(CallStatus callstatus, AudioMode audiomode)
+{
+    QMetaObject::invokeMethod(mWorker, "setCallMode", Qt::QueuedConnection, Q_ARG(CallStatus, callstatus), Q_ARG(AudioMode, audiomode));
+}
+
+void QPulseAudioEngine::setMicMute(bool muted)
+{
+    QMetaObject::invokeMethod(mWorker, "setMicMute", Qt::QueuedConnection, Q_ARG(bool, muted));
+}
+
+QT_END_NAMESPACE
+

=== added file 'handler/qpulseaudioengine.h'
--- handler/qpulseaudioengine.h	1970-01-01 00:00:00 +0000
+++ handler/qpulseaudioengine.h	2017-02-03 19:26:41 +0000
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file was taken from qt5 and modified by 
+** David Henningsson <[e-mail]> for usage in 
+** telepathy-ofono.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#ifndef QPULSEAUDIOENGINE_H
+#define QPULSEAUDIOENGINE_H
+
+#include <QtCore/qmap.h>
+#include <QtCore/qbytearray.h>
+#include <QThread>
+#include <pulse/pulseaudio.h>
+
+enum AudioMode {
+    AudioModeEarpiece = 0x0001,
+    AudioModeWiredHeadset = 0x0002,
+    AudioModeSpeaker = 0x0004,
+    AudioModeBluetooth = 0x0008,
+    AudioModeBtOrWiredOrEarpiece = AudioModeBluetooth | AudioModeWiredHeadset | AudioModeEarpiece,
+    AudioModeWiredOrEarpiece = AudioModeWiredHeadset | AudioModeEarpiece,
+    AudioModeWiredOrSpeaker = AudioModeWiredHeadset | AudioModeSpeaker,
+    AudioModeBtOrWiredOrSpeaker = AudioModeBluetooth | AudioModeWiredOrSpeaker
+};
+
+Q_DECLARE_METATYPE(AudioMode)
+
+typedef QList<AudioMode> AudioModes;
+Q_DECLARE_METATYPE(AudioModes)
+
+enum CallStatus {
+    CallRinging,
+    CallActive,
+    CallEnded
+};
+
+Q_DECLARE_METATYPE(CallStatus)
+
+QT_BEGIN_NAMESPACE
+
+class QPulseAudioEngineWorker : public QObject
+{
+    Q_OBJECT
+
+public:
+    QPulseAudioEngineWorker(QObject *parent = 0);
+    ~QPulseAudioEngineWorker();
+
+    pa_threaded_mainloop *mainloop() { return m_mainLoop; }
+    pa_context *context() { return m_context; }
+    bool createPulseContext(void);
+    int setupVoiceCall(void);
+    void restoreVoiceCall(void);
+    /* Callbacks to be used internally */
+    void cardInfoCallback(const pa_card_info *card);
+    void sinkInfoCallback(const pa_sink_info *sink);
+    void sourceInfoCallback(const pa_source_info *source);
+    void serverInfoCallback(const pa_server_info *server);
+    void plugCardCallback(const pa_card_info *card);
+    void updateCardCallback(const pa_card_info *card);
+    void unplugCardCallback();
+
+Q_SIGNALS:
+    void audioModeChanged(const AudioMode mode);
+    void availableAudioModesChanged(const AudioModes modes);
+
+public Q_SLOTS:
+    void handleCardEvent(const int evt, const unsigned int idx);
+    void setCallMode(CallStatus callstatus, AudioMode audiomode);
+    void setMicMute(bool muted); /* True if muted, false if unmuted */
+
+private:
+    pa_mainloop_api *m_mainLoopApi;
+    pa_threaded_mainloop *m_mainLoop;
+    pa_context *m_context;
+
+    AudioModes m_availableAudioModes;
+    CallStatus m_callstatus;
+    AudioMode m_audiomode;
+    AudioMode m_audiomodetoset;
+    bool m_micmute, m_handleevent;
+    std::string m_nametoset, m_valuetoset;
+    std::string m_defaultsink, m_defaultsource;
+    std::string m_bt_hsp, m_bt_hsp_a2dp;
+    std::string m_default_bt_card_fallback;
+    std::string m_voicecallcard, m_voicecallhighest, m_voicecallprofile;
+
+    bool handleOperation(pa_operation *operation, const char *func_name);
+    void releasePulseContext(void);
+};
+
+class QPulseAudioEngine : public QObject
+{
+    Q_OBJECT
+public:
+    explicit QPulseAudioEngine(QObject *parent = 0);
+    ~QPulseAudioEngine();
+    static QPulseAudioEngine *instance();
+
+    void setCallMode(CallStatus callstatus, AudioMode audiomode);
+    void setMicMute(bool muted); /* True if muted, false if unmuted */
+
+Q_SIGNALS:
+    void audioModeChanged(const AudioMode mode);
+    void availableAudioModesChanged(const AudioModes modes);
+private:
+    QPulseAudioEngineWorker *mWorker;
+    QThread mThread;
+};
+
+QT_END_NAMESPACE
+
+#endif

=== modified file 'libtelephonyservice/audiooutput.cpp'
--- libtelephonyservice/audiooutput.cpp	2014-08-25 14:49:53 +0000
+++ libtelephonyservice/audiooutput.cpp	2017-02-03 19:26:41 +0000
@@ -21,6 +21,23 @@
 
 #include "audiooutput.h"
 
+QDBusArgument &operator<<(QDBusArgument &argument, const AudioOutputDBus &output)
+{
+    argument.beginStructure();
+    argument << output.id << output.type << output.name;
+    argument.endStructure();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, AudioOutputDBus &output)
+{
+    argument.beginStructure();
+    argument >> output.id >> output.type >> output.name;
+    argument.endStructure();
+    return argument;
+}
+
+
 AudioOutput::AudioOutput(const QString& id, const QString& name, const QString& type, QObject *parent) :
     QObject(parent), mId(id), mName(name), mType(type)
 {

=== modified file 'libtelephonyservice/audiooutput.h'
--- libtelephonyservice/audiooutput.h	2014-08-25 14:49:53 +0000
+++ libtelephonyservice/audiooutput.h	2017-02-03 19:26:41 +0000
@@ -23,6 +23,7 @@
 #define AUDIOOUTPUT_H
 
 #include <QObject>
+#include <QDBusArgument>
 
 struct AudioOutputDBus {
     QString id;
@@ -53,4 +54,7 @@
     QString mType;
 };
 
+QDBusArgument &operator<<(QDBusArgument &argument, const AudioOutputDBus &output);
+const QDBusArgument &operator>>(const QDBusArgument &argument, AudioOutputDBus &output);
+
 #endif // AUDIOOUTPUT_H

=== modified file 'libtelephonyservice/callentry.cpp'
--- libtelephonyservice/callentry.cpp	2017-02-03 19:26:41 +0000
+++ libtelephonyservice/callentry.cpp	2017-02-03 19:26:41 +0000
@@ -38,30 +38,16 @@
 #define PROPERTY_AUDIO_OUTPUTS "AudioOutputs"
 #define PROPERTY_ACTIVE_AUDIO_OUTPUT "ActiveAudioOutput"
 
-QDBusArgument &operator<<(QDBusArgument &argument, const AudioOutputDBus &output)
-{
-    argument.beginStructure();
-    argument << output.id << output.type << output.name;
-    argument.endStructure();
-    return argument;
-}
-
-const QDBusArgument &operator>>(const QDBusArgument &argument, AudioOutputDBus &output)
-{
-    argument.beginStructure();
-    argument >> output.id >> output.type >> output.name;
-    argument.endStructure();
-    return argument;
-}
-
 CallEntry::CallEntry(const Tp::CallChannelPtr &channel, QObject *parent) :
     QObject(parent),
     mChannel(channel),
     mVoicemail(false),
     mLocalMuteState(false),
-    mMuteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE),
-    mAudioOutputsInterface(channel->busName(), channel->objectPath(), CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE)
+    mMuteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE)
 {
+    qRegisterMetaType<AudioOutputDBus>();
+    qRegisterMetaType<AudioOutputDBusList>();
+
     qDBusRegisterMetaType<AudioOutputDBus>();
     qDBusRegisterMetaType<AudioOutputDBusList>();
 
@@ -77,12 +63,32 @@
             SIGNAL(CallHoldingFailed(QString)),
             SLOT(onCallHoldingFailed(QString)));
 
+    connect(TelepathyHelper::instance()->handlerInterface(),
+            SIGNAL(ActiveAudioOutputChanged(QString)),
+            SLOT(onActiveAudioOutputChanged(QString)));
+
+    QDBusConnection::sessionBus().connect(TelepathyHelper::instance()->handlerInterface()->service(),
+                                          TelepathyHelper::instance()->handlerInterface()->path(),
+                                          TelepathyHelper::instance()->handlerInterface()->interface(),
+                                          "AudioOutputsChanged",
+                                          this,
+                                          SLOT(onAudioOutputsChanged(AudioOutputDBusList)));
+
     // in case the account is an ofono account, we can check the voicemail number
     OfonoAccountEntry *ofonoAccount = qobject_cast<OfonoAccountEntry*>(mAccount);
     if (ofonoAccount && !ofonoAccount->voicemailNumber().isEmpty()) {
         setVoicemail(phoneNumber() == ofonoAccount->voicemailNumber());
     }
 
+    QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
+
+    QDBusMessage reply = phoneAppHandler->call(PROPERTY_AUDIO_OUTPUTS);
+    AudioOutputDBusList audioOutputList = qdbus_cast<AudioOutputDBusList>(reply.arguments().first());
+    onAudioOutputsChanged(audioOutputList);
+
+    QString activeAudioOutput = phoneAppHandler->property(PROPERTY_ACTIVE_AUDIO_OUTPUT).toString();
+    onActiveAudioOutputChanged(activeAudioOutput);
+
     Q_EMIT incomingChanged();
 }
 
@@ -105,7 +111,8 @@
 
 void CallEntry::setActiveAudioOutput(const QString &id)
 {
-    mAudioOutputsInterface.call("SetActiveAudioOutput", id);
+    QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
+    phoneAppHandler->setProperty("ActiveAudioOutput", id);
 }
 
 void CallEntry::onActiveAudioOutputChanged(const QString &id)
@@ -198,13 +205,6 @@
 
     refreshProperties();
 
-    QDBusConnection::sessionBus().connect(mChannel->busName(), mChannel->objectPath(),
-                                          CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE,
-                                          "AudioOutputsChanged",
-                                          this,
-                                          SLOT(onAudioOutputsChanged(AudioOutputDBusList)));
-    connect(&mAudioOutputsInterface, SIGNAL(ActiveAudioOutputChanged(QString)), SLOT(onActiveAudioOutputChanged(QString)));
-
     onCallStateChanged(mChannel->callState());
 
     Q_EMIT heldChanged();
@@ -248,30 +248,18 @@
 
 void CallEntry::refreshProperties()
 {
-     QDBusInterface callChannelIface(mChannel->busName(), mChannel->objectPath(), DBUS_PROPERTIES_IFACE);
-
-     QDBusMessage reply = callChannelIface.call("GetAll", TELEPATHY_CALL_IFACE);
-     QVariantList args = reply.arguments();
-     QMap<QString, QVariant> map = qdbus_cast<QMap<QString, QVariant> >(args[0]);
-
-     reply = callChannelIface.call("GetAll", CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
-     args = reply.arguments();
-     QMap<QString, QVariant> map2 = qdbus_cast<QMap<QString, QVariant> >(args[0]);
-
-     mProperties.clear();
-     QMapIterator<QString, QVariant> i(map);
-     while(i.hasNext()) {
-         i.next();
-         mProperties[i.key()] = i.value();
-     }
-     QMapIterator<QString, QVariant> i2(map2);
-     while(i2.hasNext()) {
-         i2.next();
-         mProperties[i2.key()] = i2.value();
-     }
-
-     onAudioOutputsChanged(qdbus_cast<AudioOutputDBusList>(mProperties[PROPERTY_AUDIO_OUTPUTS]));
-     onActiveAudioOutputChanged(mProperties[PROPERTY_ACTIVE_AUDIO_OUTPUT].toString());
+    QDBusInterface callChannelIface(mChannel->busName(), mChannel->objectPath(), DBUS_PROPERTIES_IFACE);
+
+    QDBusMessage reply = callChannelIface.call("GetAll", TELEPATHY_CALL_IFACE);
+    QVariantList args = reply.arguments();
+    QMap<QString, QVariant> map = qdbus_cast<QMap<QString, QVariant> >(args[0]);
+
+    mProperties.clear();
+    QMapIterator<QString, QVariant> i(map);
+    while(i.hasNext()) {
+        i.next();
+        mProperties[i.key()] = i.value();
+    }
 }
 
 bool CallEntry::dialing() const

=== modified file 'libtelephonyservice/callentry.h'
--- libtelephonyservice/callentry.h	2017-02-03 19:26:41 +0000
+++ libtelephonyservice/callentry.h	2017-02-03 19:26:41 +0000
@@ -29,6 +29,7 @@
 #include <TelepathyQt/CallChannel>
 #include "audiooutput.h"
 
+
 class AccountEntry;
 
 class CallEntry : public QObject
@@ -179,7 +180,6 @@
     AccountEntry *mAccount;
     Tp::CallChannelPtr mChannel;
     QDBusInterface mMuteInterface;
-    QDBusInterface mAudioOutputsInterface;
     QMap<QString, QVariant> mProperties;
     bool mVoicemail;
     bool mLocalMuteState;

=== modified file 'libtelephonyservice/telepathyhelper.cpp'
--- libtelephonyservice/telepathyhelper.cpp	2017-02-03 19:26:41 +0000
+++ libtelephonyservice/telepathyhelper.cpp	2017-02-03 19:26:41 +0000
@@ -330,7 +330,6 @@
     if (name.isEmpty()) {
         name = "TelephonyPluginObserver";
     }
-
     if (mChannelObserver) {
         unregisterClient(mChannelObserver);
     }
@@ -338,13 +337,16 @@
     mChannelObserver = new ChannelObserver(this);
     mChannelObserverPtr = Tp::AbstractClientPtr(mChannelObserver);
     if (registerClient(mChannelObserver, name)) {
-        // messages
-        connect(mChannelObserver, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
-                ChatManager::instance(), SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
+        // we don't connect managers in handler, as they query the handler and cause a deadlock
+        if (QCoreApplication::applicationName() != "telephony-service-handler") {
+            // messages
+            connect(mChannelObserver, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
+                    ChatManager::instance(), SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
 
-        // calls
-        connect(mChannelObserver, SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
-                CallManager::instance(), SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
+            // calls
+            connect(mChannelObserver, SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
+                    CallManager::instance(), SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
+        }
 
         Q_EMIT channelObserverCreated(mChannelObserver);
     }

=== modified file 'libtelephonyservice/telepathyhelper.h'
--- libtelephonyservice/telepathyhelper.h	2017-02-03 19:26:41 +0000
+++ libtelephonyservice/telepathyhelper.h	2017-02-03 19:26:41 +0000
@@ -35,7 +35,6 @@
 #include "protocol.h"
 
 #define CANONICAL_TELEPHONY_VOICEMAIL_IFACE "com.canonical.Telephony.Voicemail"
-#define CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE "com.canonical.Telephony.AudioOutputs"
 #define CANONICAL_TELEPHONY_USSD_IFACE "com.canonical.Telephony.USSD"
 #define CANONICAL_TELEPHONY_EMERGENCYMODE_IFACE "com.canonical.Telephony.EmergencyMode"