Merge lp:~phablet-team/telephony-service/multiple_performance_improvements into lp:telephony-service/staging

[Tiago Salem Herrmann]

Multiple performance improvements on Roles Interfaces and ContactWatcher

Multiple performance improvements on Roles Interfaces and ContactWatcher

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

1242. By Tiago Salem Herrmann on 2017-02-06

merge parent branch

Unmerged revisions

1242. By Tiago Salem Herrmann on 2017-02-06

merge parent branch

1241. By Tiago Salem Herrmann on 2017-02-03

merge parent

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

Multiple performance fixes for contact watcher and roles interface

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

merge parent

=== added file 'handler/audioroutemanager.cpp'
--- handler/audioroutemanager.cpp	1970-01-01 00:00:00 +0000
+++ handler/audioroutemanager.cpp	2017-02-06 13:26:33 +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
+

=== removed file 'handler/audioroutemanager.cpp'
--- handler/audioroutemanager.cpp	2017-02-06 13:26:33 +0000
+++ handler/audioroutemanager.cpp	1970-01-01 00:00:00 +0000
@@ -1,231 +0,0 @@
-/*
- * 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-06 13:26:33 +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

=== removed file 'handler/audioroutemanager.h'
--- handler/audioroutemanager.h	2017-02-06 13:26:33 +0000
+++ handler/audioroutemanager.h	1970-01-01 00:00:00 +0000
@@ -1,75 +0,0 @@
-/*
- * 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

=== added file 'handler/powerd.h'
--- handler/powerd.h	1970-01-01 00:00:00 +0000
+++ handler/powerd.h	2017-02-06 13:26:33 +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

=== removed file 'handler/powerd.h'
--- handler/powerd.h	2017-02-06 13:26:33 +0000
+++ handler/powerd.h	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/**
- * 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-06 13:26:33 +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();
+    }
+}

=== removed file 'handler/powerdaudiomodemediator.cpp'
--- handler/powerdaudiomodemediator.cpp	2017-02-06 13:26:33 +0000
+++ handler/powerdaudiomodemediator.cpp	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/**
- * 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-06 13:26:33 +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

=== removed file 'handler/powerdaudiomodemediator.h'
--- handler/powerdaudiomodemediator.h	2017-02-06 13:26:33 +0000
+++ handler/powerdaudiomodemediator.h	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/****************************************************************************
-**
-** 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-06 13:26:33 +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");
+}

=== removed file 'handler/powerddbus.cpp'
--- handler/powerddbus.cpp	2017-02-06 13:26:33 +0000
+++ handler/powerddbus.cpp	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-/**
- * 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-06 13:26:33 +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

=== removed file 'handler/powerddbus.h'
--- handler/powerddbus.h	2017-02-06 13:26:33 +0000
+++ handler/powerddbus.h	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-/**
- * 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-06 13:26:33 +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
+

=== removed file 'handler/qpulseaudioengine.cpp'
--- handler/qpulseaudioengine.cpp	2017-02-06 13:26:33 +0000
+++ handler/qpulseaudioengine.cpp	1970-01-01 00:00:00 +0000
@@ -1,853 +0,0 @@
-/****************************************************************************
-**
-** 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-06 13:26:33 +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

=== removed file 'handler/qpulseaudioengine.h'
--- handler/qpulseaudioengine.h	2017-02-06 13:26:33 +0000
+++ handler/qpulseaudioengine.h	1970-01-01 00:00:00 +0000
@@ -1,126 +0,0 @@
-/****************************************************************************
-**
-** 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/chatentry.cpp'
--- libtelephonyservice/chatentry.cpp	2016-11-23 19:37:30 +0000
+++ libtelephonyservice/chatentry.cpp	2017-02-06 13:26:33 +0000
@@ -165,31 +165,42 @@
 
 void ChatEntry::onRolesChanged(const HandleRolesMap &added, const HandleRolesMap &removed)
 {
-    Q_UNUSED(added);
-    Q_UNUSED(removed);
-
-    RolesMap rolesMap;
     Tp::TextChannel* channel = 0;
     if (rolesInterface) {
-        rolesMap = rolesInterface->getRoles();
+        if (mRolesMap.isEmpty()) {
+            mRolesMap = rolesInterface->getRoles();
+        }
         channel = qvariant_cast<Tp::TextChannel*>(rolesInterface->property("channel"));
     }
 
+    QMapIterator<uint, uint> it(removed);
+    while (it.hasNext()) {
+        it.next();
+        mRolesMap.remove(it.key());
+    }
+
+    QMapIterator<uint, uint> it2(added);
+    while (it2.hasNext()) {
+        it2.next();
+        mRolesMap[it2.key()] = it2.value();
+    }
+
+    // TODO avoid iterating over all participants when not needed
     Q_FOREACH(Participant* participant, mParticipants) {
-        if (rolesMap.contains(participant->handle())) {
-            participant->setRoles(rolesMap[participant->handle()]);
+        if (mRolesMap.contains(participant->handle())) {
+            participant->setRoles(mRolesMap[participant->handle()]);
         }
     }
 
     Q_FOREACH(Participant* participant, mLocalPendingParticipants) {
-        if (rolesMap.contains(participant->handle())) {
-            participant->setRoles(rolesMap[participant->handle()]);
+        if (mRolesMap.contains(participant->handle())) {
+            participant->setRoles(mRolesMap[participant->handle()]);
         }
     }
 
     Q_FOREACH(Participant* participant, mRemotePendingParticipants) {
-        if (rolesMap.contains(participant->handle())) {
-            participant->setRoles(rolesMap[participant->handle()]);
+        if (mRolesMap.contains(participant->handle())) {
+            participant->setRoles(mRolesMap[participant->handle()]);
         }
     }
 
@@ -202,7 +213,7 @@
         return;
     }
 
-    mSelfContactRoles = rolesMap[selfContact->handle().at(0)];
+    mSelfContactRoles = mRolesMap[selfContact->handle().at(0)];
     Q_EMIT selfContactRolesChanged();
 }
 
@@ -685,15 +696,14 @@
         }
     }
 
-    RolesMap rolesMap;
-    if (rolesInterface) {
-        rolesMap = rolesInterface->getRoles();
+    if (rolesInterface && mRolesMap.isEmpty()) {
+        mRolesMap = rolesInterface->getRoles();
     }
     // now add the new participants
     // FIXME: check for duplicates?
     Q_FOREACH(Tp::ContactPtr contact, added) {
         uint handle = contact->handle().at(0);
-        list << new Participant(contact->id(), rolesMap[handle], handle, this);
+        list << new Participant(contact->id(), mRolesMap[handle], handle, this);
     }
 }
 

=== modified file 'libtelephonyservice/chatentry.h'
--- libtelephonyservice/chatentry.h	2017-02-06 13:26:33 +0000
+++ libtelephonyservice/chatentry.h	2017-02-06 13:26:33 +0000
@@ -226,6 +226,7 @@
     Tp::Client::ChannelInterfaceRoomConfigInterface *roomConfigInterface;
     Tp::Client::ChannelInterfaceSubjectInterface *subjectInterface;
     ChannelInterfaceRolesInterface *rolesInterface;
+    RolesMap mRolesMap;
 };
 
 #endif // CHATENTRY_H

=== modified file 'libtelephonyservice/contactwatcher.cpp'
--- libtelephonyservice/contactwatcher.cpp	2017-02-06 13:26:33 +0000
+++ libtelephonyservice/contactwatcher.cpp	2017-02-06 13:26:33 +0000
@@ -42,8 +42,6 @@
 ContactWatcher::ContactWatcher(QObject *parent) :
     QObject(parent), mRequest(0), mInteractive(false), mCompleted(false)
 {
-    // addressable VCard fields defaults to "tel" only
-    mAddressableFields << "tel";
     connect(ContactUtils::sharedManager(),
             SIGNAL(contactsAdded(QList<QContactId>)),
             SLOT(onContactsAdded(QList<QContactId>)));
@@ -67,7 +65,7 @@
 
 void ContactWatcher::startSearching()
 {
-    if (!mCompleted || mIdentifier.isEmpty() || !mInteractive) {
+    if (!mCompleted || mIdentifier.isEmpty() || !mInteractive || mAddressableFields.isEmpty()) {
         // component is not ready yet or no identifier given,
         // or the number is not interactive and thus doesn't need contact info at all
         return;
@@ -271,10 +269,6 @@
 void ContactWatcher::setAddressableFields(const QStringList &fields)
 {
     mAddressableFields = fields;
-    // if the addressable fields is empty, fall back to matching phone numbers
-    if (mAddressableFields.isEmpty()) {
-            mAddressableFields << "tel";
-    }
     Q_EMIT addressableFieldsChanged();
 
     startSearching();

=== modified file 'tests/Ubuntu.Telephony/ContactWatcherTest.cpp'
--- tests/Ubuntu.Telephony/ContactWatcherTest.cpp	2015-10-09 19:48:07 +0000
+++ tests/Ubuntu.Telephony/ContactWatcherTest.cpp	2017-02-06 13:26:33 +0000
@@ -95,7 +95,7 @@
 
     // set the phone number and wait for the match to happen
     watcher.setIdentifier(identifier);
-
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // contact fetching is asynchronous so use QTRY_COMPARE for the first signal spy
     // for the subsequent ones it is fine to use just QCOMPARE
@@ -128,6 +128,7 @@
     QSignalSpy unknownSpy(&watcher, SIGNAL(isUnknownChanged()));
 
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // now create the contact and wait to see if it gets matched
     QContact contact = createContact("FirstName",
@@ -169,6 +170,7 @@
     ContactWatcher watcher;
     watcher.componentComplete();
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     QSignalSpy contactIdSpy(&watcher, SIGNAL(contactIdChanged()));
     QSignalSpy aliasSpy(&watcher, SIGNAL(aliasChanged()));
@@ -218,6 +220,7 @@
 
     // set the phone number and wait for the match to happen
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // at this point we just need to make sure the contactId is correct, the other fields
     // are tested in a separate test
@@ -269,6 +272,7 @@
 
     // set the phone number and wait for the match to happen
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // at this point we just need to make sure the contactId is correct, the other fields
     // are tested in a separate test
@@ -318,6 +322,7 @@
 
     // set the phone number and wait for the match to happen
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // at this point we just need to make sure the contactId is correct, the other fields
     // are tested in a separate test
@@ -396,6 +401,7 @@
 
     // set the phone number and wait for the match to happen
     watcher.setIdentifier(identifier);
+    watcher.setAddressableFields(QStringList() << "tel");
 
     // component not complete yet
     QTRY_COMPARE(contactIdSpy.count(), 0);
@@ -430,8 +436,8 @@
     ContactWatcher watcher;
 
     // check that addressable fields contains "tel" by default
-    QCOMPARE(watcher.addressableFields().count(), 1);
-    QCOMPARE(watcher.addressableFields()[0], QString("tel"));
+    QCOMPARE(watcher.addressableFields().count(), 0);
+    QCOMPARE(watcher.addressableFields(), QStringList());
 
     QSignalSpy addressableFieldsSpy(&watcher, SIGNAL(addressableFieldsChanged()));
     QStringList addressableFields;
@@ -442,8 +448,8 @@
 
     // set the addressable fields to an empty value and make sure it falls back to "tel"
     watcher.setAddressableFields(QStringList());
-    QCOMPARE(watcher.addressableFields().count(), 1);
-    QCOMPARE(watcher.addressableFields()[0], QString("tel"));
+    QCOMPARE(watcher.addressableFields().count(), 0);
+    QCOMPARE(watcher.addressableFields(), QStringList());
 }
 
 void ContactWatcherTest::testExtendedFieldMatch()
@@ -496,6 +502,7 @@
 
     // try to match contact A
     watcherA.setIdentifier(contactIdentifierA);
+    watcherA.setAddressableFields(QStringList() << "tel");
 
     // mark as complete
     watcherA.componentComplete();
@@ -513,6 +520,7 @@
 
     // try to match contact B
     watcherB.setIdentifier(contactIdentifierB);
+    watcherB.setAddressableFields(QStringList() << "tel");
 
     // signal will be fired now
     QTRY_COMPARE(contactIdSpyB.count(), 1);