Merge lp:telephony-service/staging into lp:telephony-service

[Gustavo Pichorim Boiko]

- Add new property to .protocol files to allow join existing channels.
- Add VOIP support to telephony-service.
- Create unity8 sip and irc account packages.
- Add more properties to the .protocol files
- Expose method on dbus to leave all rooms from a certain account.
- Fix protocol filters
- Uses "ua_url_dispatcher_session_open" to launch external apps. That fixes some problems with "ua_url_dispatcher_session_open" not working on Desktop.
- Add method to leave channel by properties.
- Implement AudioRouteManager in telephony-service-handler
- Multiple performance improvements on Roles Interfaces and ContactWatcher
- Changed upstart job to also launch telephony-service-indicator on desktop
- Add ParticipantsModel
- Expose the account parameters to QML
- Export startChat to QML.
- Implemented contact match by online accounts (IRC).
- Monitor app and disconnect/connect accounts when appropriate.

- Add new property to .protocol files to allow join existing channels.
- Add VOIP support to telephony-service.
- Create unity8 sip and irc account packages.
- Add more properties to the .protocol files
- Expose method on dbus to leave all rooms from a certain account.
- Fix protocol filters
- Uses "ua_url_dispatcher_session_open" to launch external apps. That fixes some problems with "ua_url_dispatcher_session_open" not working on Desktop.
- Add method to leave channel by properties.
- Implement AudioRouteManager in telephony-service-handler
- Multiple performance improvements on Roles Interfaces and ContactWatcher
- Changed upstart job to also launch telephony-service-indicator on desktop
- Add ParticipantsModel
- Expose the account parameters to QML
- Export startChat to QML.
- Implemented contact match by online accounts (IRC).
- Monitor app and disconnect/connect accounts when appropriate.

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:1251
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/1/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/2343/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/2343
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2161
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2161/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2161/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2161/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2161
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2161/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2161
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2161/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2161
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2161/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/1/rebuild

review: Needs Fixing (continuous-integration)

[lp:telephony-service/staging]

1252. By Gustavo Pichorim Boiko on 2017-03-23

Disable PA on tests.

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:1252
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/2/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/2350/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/2350
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2168/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2168
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2168/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2168
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2168/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2168
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2168/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2168
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2168/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2168
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2168/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/2/rebuild

review: Needs Fixing (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

The changes were reviewed individually and tested from this branch, so approving.

review: Approve

[lp:telephony-service/staging]

1253. By Tiago Salem Herrmann on 2017-03-29

- Initialize pointer to avoid crashes.
- Connect new accounts in case messaging-app is already active

1254. By Tiago Salem Herrmann on 2017-03-31

- Use alsasrc as a workaround to be able to record from the microphone.
pulsesrc does not work on some environments.

1255. By Tiago Salem Herrmann on 2017-04-04

Add requires to telepathy-rakia and mfw-plugin-irc

1256. By Gustavo Pichorim Boiko on 2017-04-05

Fix watching the connection status changes and properly notify the changes to displayed accounts

Unmerged revisions

1256. By Gustavo Pichorim Boiko on 2017-04-05

Fix watching the connection status changes and properly notify the changes to displayed accounts

1255. By Tiago Salem Herrmann on 2017-04-04

Add requires to telepathy-rakia and mfw-plugin-irc

1254. By Tiago Salem Herrmann on 2017-03-31

- Use alsasrc as a workaround to be able to record from the microphone.
pulsesrc does not work on some environments.

1253. By Tiago Salem Herrmann on 2017-03-29

- Initialize pointer to avoid crashes.
- Connect new accounts in case messaging-app is already active

1252. By Gustavo Pichorim Boiko on 2017-03-23

Disable PA on tests.

1251. By Gustavo Pichorim Boiko on 2017-03-22

Monitor app and disconnect/connect accounts when appropriate.

1250. By Gustavo Pichorim Boiko on 2017-03-22

Implemented contact match by online accounts (IRC).

1249. By Gustavo Pichorim Boiko on 2017-03-22

Export startChat to QML.

1248. By Gustavo Pichorim Boiko on 2017-03-22

Expose the account parameters to QML

1247. By Gustavo Pichorim Boiko on 2017-03-22

Add ParticipantsModel

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-10-06 19:41:33 +0000
+++ CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -15,13 +15,6 @@
 # just to make debug easier, print the system processor
 message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}")
 
-# Check if should build using ubuntu platform api
-check_include_file_cxx("ubuntu/application/init.h" USE_UBUNTU_PLATFORM_API)
-
-if (USE_UBUNTU_PLATFORM_API)
-    add_definitions(-DUSE_UBUNTU_PLATFORM_API)
-endif (USE_UBUNTU_PLATFORM_API)
-
 set(TELEPHONY_SERVICE_DIR ${CMAKE_INSTALL_DATADIR}/telephony-service)
 
 configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h @ONLY)
@@ -35,10 +28,8 @@
 
 find_package(Qt5Contacts)
 find_package(Qt5DBus)
-#find_package(Qt5Gui)
 find_package(Qt5Multimedia)
 find_package(Qt5Qml)
-#find_package(Qt5Quick)
 find_package(Qt5Test)
 find_package(Qt5Feedback)
 find_package(Qt5Network)
@@ -48,7 +39,7 @@
 
 option(SKIP_QML_TESTS "Skip QML tests" OFF)
 
-if(NOT CMAKE_CROSSCOMPILING)
+if(CMAKE_CROSSCOMPILING)
     find_program(QMAKE_EXECUTABLE qmake)
     if(QMAKE_EXECUTABLE STREQUAL "QMAKE_EXECUTABLE-NOTFOUND")
         message(FATAL_ERROR "qmake not found")
@@ -71,10 +62,18 @@
 
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(TP_QT5 REQUIRED TelepathyQt5)
+pkg_check_modules(TP_QT5_FS REQUIRED TelepathyQt5Farstream)
 pkg_check_modules(NOTIFY REQUIRED libnotify)
 pkg_check_modules(MESSAGING_MENU REQUIRED messaging-menu)
 pkg_check_modules(UserMetrics REQUIRED libusermetricsinput-1)
 pkg_check_modules(HISTORY REQUIRED history-service)
+pkg_check_modules(TPFS REQUIRED telepathy-farstream)
+pkg_check_modules(GST REQUIRED gstreamer-1.0)
+pkg_check_modules(FS REQUIRED farstream-0.2)
+pkg_check_modules(UBUNTU_PLATFORM_API ubuntu-platform-api)
+pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
+pkg_check_modules(PULSEAUDIO libpulse)
+pkg_check_modules(URL_DISPATCHER REQUIRED url-dispatcher-1)
 
 add_definitions(-DQT_NO_KEYWORDS)
 
@@ -110,6 +109,7 @@
 add_subdirectory(po)
 add_subdirectory(tests)
 add_subdirectory(protocols)
+add_subdirectory(accounts)
 
 include(EnableCoverageReport)
 #####################################################################
 
=== modified file 'TODO'
--- TODO	2012-11-27 12:21:47 +0000
+++ TODO	2017-04-05 14:05:16 +0000
@@ -1,6 +1,9 @@
 General items
 - Formatting of phone numbers
 - Check how to import/export potfiles from the ts one
+- Add an automated test to check if features are getting correctly exported
+  by AccountEntry
+- Implement unit test for launching external app from indicator.
 
 Contact integration items:
 - Fix contact search when names contain accentuated characters
@@ -16,3 +19,6 @@
   places
 - Change the ChannelObserver and the ChannelApprover code to allow using from
   both places.
+
+Handler
+- Move app monitoring to from TextHandler to ApplicationUtils
 
=== modified file 'Ubuntu/Telephony/CMakeLists.txt'
--- Ubuntu/Telephony/CMakeLists.txt	2016-07-05 03:34:11 +0000
+++ Ubuntu/Telephony/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -2,6 +2,7 @@
 
 set(plugin_SRCS
     presencerequest.cpp
+    participantsmodel.cpp
     components.cpp
     )
 
 
=== modified file 'Ubuntu/Telephony/components.cpp'
--- Ubuntu/Telephony/components.cpp	2016-11-23 19:28:18 +0000
+++ Ubuntu/Telephony/components.cpp	2017-04-05 14:05:16 +0000
@@ -39,6 +39,7 @@
 #include "accountentry.h"
 #include "accountlist.h"
 #include "audiooutput.h"
+#include "participantsmodel.h"
 
 #include <QQmlEngine>
 #include <qqml.h>
@@ -87,5 +88,6 @@
     qmlRegisterType<ContactWatcher>(uri, 0, 1, "ContactWatcher");
     qmlRegisterType<Participant>(uri, 0, 1, "Participant");
     qmlRegisterType<PresenceRequest>(uri, 0, 1, "PresenceRequest");
+    qmlRegisterType<ParticipantsModel>(uri, 0, 1, "ParticipantsModel");
     qmlRegisterType<PhoneUtils>(uri, 0, 1, "PhoneUtils");
 }
 
=== added file 'Ubuntu/Telephony/participantsmodel.cpp'
--- Ubuntu/Telephony/participantsmodel.cpp	1970-01-01 00:00:00 +0000
+++ Ubuntu/Telephony/participantsmodel.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2013-2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *  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 "participantsmodel.h"
+#include <participant.h>
+#include <QDebug>
+
+Q_DECLARE_METATYPE(Participant)
+
+ParticipantsModel::ParticipantsModel(QObject *parent) :
+    QAbstractListModel(parent), mWaitingForQml(false), mCanFetchMore(true), mChatEntry(NULL)
+{
+    qRegisterMetaType<Participant>();
+    mRoles[AliasRole] = "alias";
+    mRoles[IdentifierRole] = "identifier";
+    mRoles[RolesRole] = "roles";
+    mRoles[StateRole] = "state";
+
+    connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SIGNAL(countChanged()));
+    connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SIGNAL(countChanged()));
+    connect(this, SIGNAL(modelReset()), this, SIGNAL(countChanged()));
+}
+
+bool ParticipantsModel::canFetchMore(const QModelIndex &parent) const
+{
+    return !mParticipantsCache.isEmpty();
+}
+
+ParticipantsModel::~ParticipantsModel()
+{
+}
+
+void ParticipantsModel::fetchMore(const QModelIndex &parent)
+{
+    if (parent.isValid() ) {
+        return;
+    }
+
+    int max = 14;
+    while (max >= 0 && !mParticipantsCache.isEmpty()) {
+        addParticipant(mParticipantsCache.takeFirst());
+        max--;
+    }
+
+    if (mParticipantsCache.isEmpty()) {
+        mCanFetchMore = false;
+        Q_EMIT canFetchMoreChanged();
+    }
+}
+
+int ParticipantsModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return mParticipants.count();
+}
+
+QHash<int, QByteArray> ParticipantsModel::roleNames() const
+{
+    return mRoles;
+}
+
+void ParticipantsModel::addParticipantCache(Participant *participant)
+{
+    int pos = positionForItem(participant->identifier(), true);
+    mParticipantsCache.insert(pos, participant);
+}
+
+void ParticipantsModel::addParticipant(Participant *participant)
+{
+    int pos = positionForItem(participant->identifier());
+    beginInsertRows(QModelIndex(), pos, pos);
+    mParticipants.insert(pos, participant);
+    endInsertRows();
+}
+
+void ParticipantsModel::removeParticipant(Participant *participant)
+{
+    int pos = mParticipants.indexOf(participant);
+    if (pos >= 0) {
+        beginRemoveRows(QModelIndex(), pos, pos);
+        mParticipants.removeAt(pos);
+        endRemoveRows();
+    }
+    pos = mParticipantsCache.indexOf(participant);
+    if (pos >= 0) {
+        mParticipantsCache.removeAt(pos);
+    }
+}
+
+QVariant ParticipantsModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() < 0 || index.row() >= rowCount()) {
+        return QVariant();
+    }
+    switch (role) {
+    case IdentifierRole:
+        return mParticipants[index.row()]->identifier();
+    break;
+    case AliasRole:
+        return mParticipants[index.row()]->alias();
+    break;
+    case StateRole:
+        return 0;
+    break;
+    case RolesRole:
+        return mParticipants[index.row()]->roles();
+    break;
+    }
+    return QVariant();
+}
+
+bool ParticipantsModel::lessThan(const QString &left, const QString &right) const
+{
+    // this method will push participant with names starting with non-letter
+    // characters to the end of the list
+    if (left.isEmpty() || right.isEmpty()) {
+        return false;
+    }
+    if (left.at(0).isLetter() && right.at(0).isLetter()) {
+        return left.localeAwareCompare(right) < 0;
+    }
+    if (!left.at(0).isLetter() && right.at(0).isLetter()) {
+        return false;
+    }
+    if (left.at(0).isLetter() && !right.at(0).isLetter()) {
+        return true;
+    }
+
+    return false;
+}
+
+int ParticipantsModel::positionForItem(const QString &item, bool cache) const
+{
+    // do a binary search for the item position on the list
+    int lowerBound = 0;
+    int upperBound = cache ? mParticipantsCache.count() - 1 : rowCount() - 1;
+    if (upperBound < 0) {
+        return 0;
+    }
+
+    while (true) {
+        int pos = (upperBound + lowerBound) / 2;
+        const QString posItem = cache ? mParticipantsCache[pos]->identifier() : index(pos).data(IdentifierRole).toString();
+        if (lowerBound == pos) {
+            if (lessThan(item, posItem)) {
+                return pos;
+            }
+        }
+        if (lessThan(posItem, item)) {
+            lowerBound = pos + 1;          // its in the upper
+            if (lowerBound > upperBound) {
+                return pos += 1;
+            }
+        } else if (lowerBound > upperBound) {
+            return pos;
+        } else {
+            upperBound = pos - 1;          // its in the lower
+        }
+    }
+}
+
+void ParticipantsModel::classBegin()
+{
+    mWaitingForQml = true;
+}
+
+void ParticipantsModel::componentComplete()
+{
+    mWaitingForQml = false;
+}
+
+QVariant ParticipantsModel::get(int row) const
+{
+    QVariantMap data;
+    QModelIndex idx = index(row, 0);
+    if (idx.isValid()) {
+        QHash<int, QByteArray> roles = roleNames();
+        Q_FOREACH(int role, roles.keys()) {
+            data.insert(roles[role], idx.data(role));
+        }
+    }
+
+    return data;
+}
+
+ChatEntry* ParticipantsModel::chatEntry() const
+{
+    return mChatEntry;
+}
+
+void ParticipantsModel::setChatEntry(ChatEntry *entry)
+{
+    if (mChatEntry == entry) {
+        return;
+    }
+    ChatEntry *previousChatEntry = mChatEntry;
+    mChatEntry = entry;
+    if (!entry) {
+        return;
+    }
+    if (previousChatEntry) {
+        previousChatEntry->disconnect(this);
+    }
+    connect(mChatEntry, SIGNAL(participantAdded(Participant *)), SLOT(addParticipant(Participant *)));
+    connect(mChatEntry, SIGNAL(participantRemoved(Participant *)), SLOT(removeParticipant(Participant *)));
+    Q_FOREACH(Participant *participant, mChatEntry->allParticipants()) {
+        addParticipantCache(participant);
+    }
+    fetchMore();
+    mCanFetchMore = !mParticipantsCache.isEmpty();
+    Q_EMIT canFetchMoreChanged();
+    Q_EMIT chatEntryChanged();
+}
 
=== added file 'Ubuntu/Telephony/participantsmodel.h'
--- Ubuntu/Telephony/participantsmodel.h	1970-01-01 00:00:00 +0000
+++ Ubuntu/Telephony/participantsmodel.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2013-2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *  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 PARTICIPANTSMODEL_H
+#define PARTICIPANTSMODEL_H
+
+#include "chatentry.h"
+#include <QAbstractListModel>
+#include <QStringList>
+#include <QQmlParserStatus>
+#include <QQmlListProperty>
+
+class Participant;
+
+class ParticipantsModel : public QAbstractListModel, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+    Q_PROPERTY(int count READ rowCount NOTIFY countChanged)
+    Q_PROPERTY(bool canFetchMore READ canFetchMore NOTIFY canFetchMoreChanged)
+    Q_PROPERTY(ChatEntry* chatEntry READ chatEntry WRITE setChatEntry NOTIFY chatEntryChanged)
+    Q_ENUMS(Role)
+
+public:
+    enum Role {
+        IdentifierRole = Qt::UserRole,
+        AliasRole,
+        RolesRole,
+        StateRole
+    };
+
+    explicit ParticipantsModel(QObject *parent = 0);
+    ~ParticipantsModel();
+
+    Q_INVOKABLE virtual bool canFetchMore(const QModelIndex &parent = QModelIndex()) const;
+    Q_INVOKABLE virtual void fetchMore(const QModelIndex &parent = QModelIndex());
+    virtual QHash<int, QByteArray> roleNames() const;
+    virtual QVariant data(const QModelIndex &index, int role) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+
+    Q_INVOKABLE virtual QVariant get(int row) const;
+
+    Q_INVOKABLE void setChatEntry(ChatEntry *entry);
+    ChatEntry* chatEntry() const;
+
+    void addParticipantCache(Participant *participant);
+
+    void classBegin();
+    void componentComplete();
+
+private Q_SLOTS:
+    void addParticipant(Participant *participant);
+    void removeParticipant(Participant *participant);
+
+Q_SIGNALS:
+    void countChanged();
+    void canFetchMoreChanged();
+    void chatEntryChanged();
+
+protected:
+    bool lessThan(const QString &left, const QString &right) const;
+    int positionForItem(const QString &item, bool cache = false) const;
+
+private:
+    QHash<int, QByteArray> mRoles;
+    QList<Participant*> mParticipants;
+    bool mWaitingForQml;
+    bool mCanFetchMore;
+    ChatEntry *mChatEntry;
+    QList<Participant*> mParticipantsCache;
+};
+
+#endif // PARTICIPANTSMODEL_H
 
=== added directory 'accounts'
=== added file 'accounts/CMakeLists.txt'
--- accounts/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(sip)
+add_subdirectory(irc)
 
=== added directory 'accounts/common'
=== added file 'accounts/common/DynamicField.qml'
--- accounts/common/DynamicField.qml	1970-01-01 00:00:00 +0000
+++ accounts/common/DynamicField.qml	2017-04-05 14:05:16 +0000
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Renato Araujo Oliveira Filho <[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/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.3
+
+Loader {
+    id: root
+
+    property var model
+    readonly property string value: status === Loader.Ready ? item.value : ""
+    readonly property bool isEmpty: status === Loader.Ready ? item.isEmpty : true
+
+    Component {
+        id: stringField
+
+        TextField {
+            id: field
+
+            property alias label: field.placeholderText
+            property string defaultValue
+
+            readonly property alias value: field.text
+            readonly property bool isEmpty: value === "" || (defaultValue && value === model.defaultValue)
+
+            text: defaultValue ? defaultValue : ""
+        }
+    }
+
+    Component {
+        id: booleanField
+
+        Item {
+            property alias label: fieldLabel.text
+            property string defaultValue
+
+            readonly property string value: fieldValue.checked ? "true" : "false"
+            readonly property bool isEmpty: (defaultValue && value === model.defaultValue)
+
+            height: fieldValue.height
+
+            Label {
+                id: fieldLabel
+
+                anchors {
+                    left: parent.left
+                    right: fieldValue.left
+                    verticalCenter: parent.verticalCenter
+                }
+            }
+            Switch {
+                id: fieldValue
+
+                anchors {
+                    right: parent.right
+                    verticalCenter: parent.verticalCenter
+                }
+                checked: (defaultValue && (defaultValue === 'true'))
+            }
+        }
+    }
+
+    Component {
+       id: numericField
+
+       TextField {
+           id: field
+
+           property alias label: field.placeholderText
+           property string defaultValue
+
+           readonly property alias value: field.text
+           readonly property bool isEmpty: value === "" || (defaultValue && (value === defaultValue))
+
+           inputMethodHints: Qt.ImhDigitsOnly
+           validator: IntValidator {}
+       }
+    }
+
+    Component{
+        id: passwordField
+
+        Item {
+            property alias label: field.placeholderText
+            readonly property alias value: field.text
+            readonly property bool isEmpty: value === ""
+
+            height: field.height + showPasswordCheck.height
+            TextField {
+                id: field
+
+                echoMode: showPasswordCheck.checked ? TextInput.Normal : TextInput.Password
+                anchors {
+                    left: parent.left
+                    right: parent.right
+                }
+                onTextChanged: root.changed()
+            }
+            CheckBox {
+                id: showPasswordCheck
+                anchors {
+                    left: field.left
+                    top: field.bottom
+                    topMargin: units.gu(1)
+                }
+            }
+            Label {
+                text: i18n.tr("Show Password")
+                anchors {
+                    top: showPasswordCheck.top
+                    left: showPasswordCheck.right
+                    leftMargin: units.gu(1)
+                    right: field.right
+                }
+            }
+        }
+    }
+
+
+    sourceComponent: {
+        if (!model)
+            return null
+
+        if (!model.inputType) {
+            console.warn("Model does not contain 'inputType'")
+            return null
+        }
+
+        switch (model.inputType) {
+        case 'string':
+            return stringField
+        case 'boolean':
+            return booleanField
+        case 'numeric':
+            return numericField
+        case 'password':
+            return passwordField
+        }
+    }
+
+    Binding {
+        target: root.item
+        property: "label"
+        value: model.label
+        when: root.status == Loader.Ready
+    }
+
+    Binding {
+        target: root.item
+        property: "defaultValue"
+        value: model.defaultValue
+        when: model.hasOwnProperty('defaultValue') && root.status == Loader.Ready
+    }
+}
 
=== added file 'accounts/common/Main.qml'
--- accounts/common/Main.qml	1970-01-01 00:00:00 +0000
+++ accounts/common/Main.qml	2017-04-05 14:05:16 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Renato Araujo Oliveira Filho <[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/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.3
+import Ubuntu.OnlineAccounts.Plugin 1.0
+
+Item {
+    id: rootFlickable
+
+    property int keyboardSize: Qt.inputMethod.visible ? Qt.inputMethod.keyboardRectangle.height : 0
+
+    signal finished
+
+    anchors.fill: parent
+
+    Flickable {
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: parent.top
+            bottom: btnConfirm.top
+        }
+        contentWidth: parent.width
+        contentHeight: editPageLoader.item.height + keyboardSize
+        clip: true
+
+        Loader {
+            id: editPageLoader
+            sourceComponent: account.accountId != 0 ? existingAccountComponent : newAccountComponent
+            anchors {
+                left: parent.left
+                right: parent.right
+            }
+
+            Connections {
+                target: editPageLoader.item
+                onFinished: rootFlickable.finished()
+            }
+        }
+
+        Component {
+            id: newAccountComponent
+            NewAccount {}
+        }
+
+        Component {
+            id: existingAccountComponent
+            Options {}
+        }
+    }
+
+    Button {
+        id: btnConfirm
+        text: i18n.tr("Continue")
+        color: UbuntuColors.orange
+        anchors {
+            left: parent.left
+            right: parent.right
+            bottom: btnCancel.top
+            margins: units.gu(2)
+            bottomMargin: units.gu(1)
+        }
+        enabled: editPageLoader.item && editPageLoader.item.isValid
+        onClicked: {
+            if (editPageLoader.item)
+                editPageLoader.item.confirm()
+        }
+
+    }
+
+    Button {
+        id: btnCancel
+
+        text: i18n.tr("Cancel")
+        anchors {
+            left: parent.left
+            right: parent.right
+            bottom: parent.bottom
+            margins: units.gu(2)
+            bottomMargin: units.gu(1)
+        }
+        onClicked: {
+            if (editPageLoader.item)
+                editPageLoader.item.cancel()
+        }
+    }
+}
 
=== added file 'accounts/common/NewAccountInterface.qml'
--- accounts/common/NewAccountInterface.qml	1970-01-01 00:00:00 +0000
+++ accounts/common/NewAccountInterface.qml	2017-04-05 14:05:16 +0000
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Renato Araujo Oliveira Filho <[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/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.3
+import Ubuntu.OnlineAccounts 0.1
+
+Item {
+    id: root
+
+    readonly property string keyPrefix: "telepathy/"
+    readonly property var accountObjectHandle: account ? account.objectHandle : undefined
+    readonly property alias isValid: paramsRepeater.fieldHasValues
+
+    property string manager
+    property string protocol
+    property string icon
+    property var params
+    property var advancedParams
+    property bool hasCrendentials: true
+
+
+    signal finished
+    height: fields.childrenRect.height +
+            units.gu(10)
+
+    function getAccountService() {
+        var service = serviceModel.get(0, "accountServiceHandle")
+        if (!service) {
+            console.warn("No service handle from model")
+            return null
+        }
+
+        return accountServiceComponent.createObject(null,
+                                                    {"objectHandle": service})
+    }
+
+    // virual
+    function extendedSettings(inputFields)
+    {
+        return {}
+        //Helper class to be extended by derived class
+    }
+
+    // virtual
+    function formatDisplayName(inputFields)
+    {
+        return inputFields['account']
+        // Helper function that allow the derived class to format a different display name
+    }
+
+    function saveServiceSettings(serviceIM, creds) {
+        var settingsIM = serviceIM.settings
+        var inputFields = {}
+
+        settingsIM[root.keyPrefix + 'manager'] = root.manager
+        settingsIM[root.keyPrefix + 'protocol'] = root.protocol
+        settingsIM[root.keyPrefix + 'Icon'] = root.icon
+
+        // basic fields
+        for (var i=0; i < paramsRepeater.count; i++) {
+            var fieldData = root.params[i]
+            var field = paramsRepeater.itemAt(i)
+            var fieldParamName = root.keyPrefix + 'param-' + fieldData.name
+
+            if (field.isEmpty) {
+                delete settingsIM[fieldParamName]
+            } else {
+                inputFields[fieldData.name] = field.value
+                if (fieldData.store) {
+                    settingsIM[fieldParamName] = field.value
+                }
+            }
+        }
+
+        // advanced fields
+        for (var i=0; i < advancedParamsRepeater.count; i++) {
+            var xFieldData = root.advancedParams[i]
+            var xField = advancedParamsRepeater.itemAt(i)
+            var xFieldParamName = root.keyPrefix + 'param-' + xFieldData.name
+
+            if (xField.isEmpty) {
+                delete settingsIM[xFieldParamName]
+            } else {
+                inputFields[xFieldData.name] = xField.value
+
+                if (xFieldData.store) {
+                    settingsIM[xFieldParamName] = xField.value
+                }
+            }
+        }
+
+
+        var xSettings = extendedSettings(inputFields)
+        for (var key in xSettings) {
+            settingsIM[root.keyPrefix + key] = xSettings[key]
+        }
+
+        account.updateDisplayName(formatDisplayName(inputFields))
+
+        serviceIM.updateSettings(settingsIM)
+        //serviceIM.credentials = creds
+        //serviceIM.updateServiceEnabled(true)
+    }
+
+    function continueAccountSave(creds)  {
+        var imService = root.getAccountService()
+        if (!imService) {
+            console.warn("Fail to retrieve account service")
+            return
+        }
+
+        root.saveServiceSettings(imService, creds)
+        if (creds)
+            globalAccountService.credentials = creds
+        globalAccountService.updateServiceEnabled(true)
+
+        account.synced.connect(root.finished)
+        account.sync()
+    }
+
+    function credentialsStored() {
+        if (creds.credentialsId === 0) {
+            console.warn("Credentials not stored correct")
+            return
+        }
+
+        var imService = root.getAccountService()
+        if (!imService) {
+            console.warn("Fail to retrieve account service")
+            return
+        }
+
+        continueAccountSave(creds)
+    }
+
+    function parseCrendentials() {
+        var credentials = {'userName': '', 'password': ''}
+
+        for (var i=0; i < paramsRepeater.count; i++) {
+            var fieldData = root.params[i]
+            var field = paramsRepeater.itemAt(i)
+
+            if (fieldData.name === 'account')
+                credentials['userName'] = field.value
+
+            if (fieldData.name === 'password')
+                credentials['password'] = field.value
+        }
+
+        return credentials
+    }
+
+    function cancel() {
+        account.removed.connect(root.finished)
+        account.remove(Account.RemoveCredentials)
+    }
+
+    function confirm() {
+        var info = root.parseCrendentials()
+        // save account
+        account.updateDisplayName(info.userName)
+        if (root.hasCrendentials) {
+            creds.userName = info.userName
+            creds.secret = info.password
+            creds.sync()
+        } else {
+            continueAccountSave(null)
+        }
+    }
+
+    Column {
+        id: fields
+
+        anchors {
+            top: parent.top
+            topMargin: units.gu(5)
+            left: parent.left
+            right: parent.right
+        }
+        height: childrenRect.height
+        spacing: units.gu(2)
+
+        Icon {
+            anchors.horizontalCenter: fields.horizontalCenter
+            name: root.icon
+        }
+
+        Repeater {
+            id: paramsRepeater
+
+            property bool fieldHasValues: false
+
+            function checkFieldsHasValues()
+            {
+                var hasEmptyField = false
+                for (var i = 0; i < paramsRepeater.count; i++) {
+
+                    var child = paramsRepeater.itemAt(i)
+                    if (child && child.isEmpty) {
+                        hasEmptyField = true
+                        break
+                    }
+                }
+                fieldHasValues = !hasEmptyField
+            }
+
+            width: parent.width
+            model: root.params
+            DynamicField {
+                model: modelData
+                anchors{
+                    left: parent.left
+                    right: parent.right
+                    margins: units.gu(4)
+                }
+                onValueChanged: paramsRepeater.checkFieldsHasValues()
+            }
+        }
+
+        Item {
+            id: div
+
+            anchors{
+                left: parent.left
+                right: parent.right
+            }
+            height: units.gu(3)
+            visible: root.advancedParams.length > 0
+        }
+
+        Label {
+            id: advancedParamsTitle
+
+            anchors{
+                left: parent.left
+                right: parent.right
+                margins: units.gu(4)
+            }
+            visible: root.advancedParams.length > 0
+            text: i18n.tr("Advanced Options")
+            textSize: Label.Medium
+        }
+
+        Repeater {
+            id: advancedParamsRepeater
+
+            width: parent.width
+            model: root.advancedParams
+            DynamicField {
+                model: modelData
+                anchors{
+                    left: parent.left
+                    right: parent.right
+                    margins: units.gu(4)
+                }
+            }
+        }
+    }
+
+    AccountService {
+        id: globalAccountService
+
+        objectHandle: account.accountServiceHandle
+        autoSync: false
+    }
+
+    Credentials {
+        id: creds
+
+        caption: account.provider.id
+        acl: "*" // untill later
+        storeSecret: true
+        onCredentialsIdChanged: {
+            console.debug("Credetials id changed")
+            root.credentialsStored()
+        }
+    }
+
+    // necessary to store settings on the "IM" service
+    AccountServiceModel {
+        id: serviceModel
+
+        includeDisabled: true
+        account: root.accountObjectHandle
+        serviceType: "IM"
+    }
+
+    Component {
+        id: accountServiceComponent
+
+        AccountService {
+            autoSync: false
+        }
+    }
+}
 
=== added directory 'accounts/irc'
=== added file 'accounts/irc/CMakeLists.txt'
--- accounts/irc/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/irc/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(qml)
+add_subdirectory(data)
 
=== added directory 'accounts/irc/data'
=== added file 'accounts/irc/data/CMakeLists.txt'
--- accounts/irc/data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/irc/data/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,5 @@
+file(GLOB PROVIDER_FILES *.provider)
+install(FILES ${PROVIDER_FILES} DESTINATION share/accounts/providers/)
+
+file(GLOB SERVICE_FILES *.service)
+install(FILES ${SERVICE_FILES} DESTINATION share/accounts/services/)
 
=== added file 'accounts/irc/data/telephony-irc-im.service'
--- accounts/irc/data/telephony-irc-im.service	1970-01-01 00:00:00 +0000
+++ accounts/irc/data/telephony-irc-im.service	2017-04-05 14:05:16 +0000
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<service id="telephony-irc-im">
+  <type>IM</type>
+  <name>IRC</name>
+  <icon>irc</icon>
+  <provider>telephony-irc</provider>
+
+  <!-- default settings (account settings have precedence over these) -->
+  <template>
+    <group name="telepathy">
+      <setting name="manager">irc</setting>
+      <setting name="protocol">irc</setting>
+      <setting name="ConnectAutomatically">false</setting>
+      <setting type="s" name="AutomaticPresence">1;offline;;</setting>
+    </group>
+    <group name="auth">
+      <setting name="method">password</setting>
+      <setting name="mechanism">password</setting>
+    </group>
+  </template>
+
+</service>
 
=== added file 'accounts/irc/data/telephony-irc.provider'
--- accounts/irc/data/telephony-irc.provider	1970-01-01 00:00:00 +0000
+++ accounts/irc/data/telephony-irc.provider	2017-04-05 14:05:16 +0000
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<provider id="telephony-irc">
+  <name>IRC</name>
+  <icon>irc</icon>
+</provider>
 
=== added directory 'accounts/irc/qml'
=== added file 'accounts/irc/qml/AccountInfo.qml'
=== added file 'accounts/irc/qml/CMakeLists.txt'
--- accounts/irc/qml/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/irc/qml/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,13 @@
+file(GLOB QML_PLUGIN_FILES *.qml)
+
+# The path (including plug-in name) where the QML files are installed
+set(QML_PLUGIN_INSTALL_DIR share/accounts/qml-plugins/telephony-irc/)
+
+# Do not install symbolic links
+set (QML_PLUGIN_RESOLVED_FILES "")
+foreach (QML_PLUGIN_FILE ${QML_PLUGIN_FILES})
+    get_filename_component(resolvedFile "${QML_PLUGIN_FILE}" REALPATH)
+    list (APPEND QML_PLUGIN_RESOLVED_FILES "${resolvedFile}")
+endforeach()
+
+install(FILES ${QML_PLUGIN_RESOLVED_FILES} DESTINATION ${QML_PLUGIN_INSTALL_DIR})
 
=== added symlink 'accounts/irc/qml/DynamicField.qml'
=== target is u'../../common/DynamicField.qml'
=== added symlink 'accounts/irc/qml/Main.qml'
=== target is u'../../common/Main.qml'
=== added file 'accounts/irc/qml/NewAccount.qml'
--- accounts/irc/qml/NewAccount.qml	1970-01-01 00:00:00 +0000
+++ accounts/irc/qml/NewAccount.qml	2017-04-05 14:05:16 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Renato Araujo Oliveira Filho <[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/>.
+ */
+
+import QtQuick 2.0
+
+NewAccountInterface {
+    id: root
+
+    anchors {
+        left: parent.left
+        right: parent.right
+        verticalCenter: parent.verticalCenter
+    }
+
+    manager: 'irc'
+    protocol: 'irc'
+    icon: 'irc'
+    hasCrendentials: false
+    params: [
+        {'name': 'server', 'inputType': 'string', 'label': i18n.tr('Network. (Eg: chat.freenode.net)'), 'store': true},
+        {'name': 'nickname', 'inputType': 'string', 'label': i18n.tr('Nickname'), 'store': true},
+    ]
+    advancedParams: [
+        {'name': 'port', 'inputType': 'numeric', 'label': i18n.tr('Port'), 'store': true},
+        {'name': 'use-ssl', 'inputType': 'boolean', 'label': i18n.tr('Use ssl'), 'store': true},
+        {'name': 'verify-ssl-cert', 'inputType': 'boolean', 'label': i18n.tr('Verify ssl certificate'), 'store': true},
+        {'name': 'username', 'inputType': 'string', 'label': i18n.tr('Username'), 'store': true},
+        {'name': 'password', 'inputType': 'password', 'label': i18n.tr('Password'), 'store': true},
+        {'name': 'fullname', 'inputType': 'string', 'label': i18n.tr('Real name'), 'store': true},
+    ]
+
+    function extendedSettings(inputFields)
+    {
+        var settings = {}
+        settings['param-account'] = inputFields['nickname'] + "@" + inputFields['server']
+        if (settings['param-port'] == "")
+            settings['param-port'] = "6667"
+        return settings
+    }
+
+    function formatDisplayName(inputFields)
+    {
+        return inputFields['nickname'] + "@" + inputFields['server']
+    }
+}
 
=== added symlink 'accounts/irc/qml/NewAccountInterface.qml'
=== target is u'../../common/NewAccountInterface.qml'
=== added directory 'accounts/sip'
=== added file 'accounts/sip/CMakeLists.txt'
--- accounts/sip/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/sip/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(qml)
+add_subdirectory(data)
 
=== added directory 'accounts/sip/data'
=== added file 'accounts/sip/data/CMakeLists.txt'
--- accounts/sip/data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/sip/data/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,5 @@
+file(GLOB PROVIDER_FILES *.provider)
+install(FILES ${PROVIDER_FILES} DESTINATION share/accounts/providers/)
+
+file(GLOB SERVICE_FILES *.service)
+install(FILES ${SERVICE_FILES} DESTINATION share/accounts/services/)
 
=== added file 'accounts/sip/data/telephony-sip-im.service'
--- accounts/sip/data/telephony-sip-im.service	1970-01-01 00:00:00 +0000
+++ accounts/sip/data/telephony-sip-im.service	2017-04-05 14:05:16 +0000
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<service id="telephony-sip-im">
+  <type>IM</type>
+  <name>SIP</name>
+  <icon>sip</icon>
+  <provider>telephony-sip</provider>
+
+  <!-- default settings (account settings have precedence over these) -->
+  <template>
+    <group name="telepathy">
+      <setting name="manager">sofiasip</setting>
+      <setting name="protocol">sip</setting>
+      <setting name="ConnectAutomatically">true</setting>
+      <setting type="s" name="AutomaticPresence">2;available;;</setting>
+    </group>
+    <group name="auth">
+      <setting name="method">password</setting>
+      <setting name="mechanism">password</setting>
+    </group>
+  </template>
+
+</service>
 
=== added file 'accounts/sip/data/telephony-sip.provider'
--- accounts/sip/data/telephony-sip.provider	1970-01-01 00:00:00 +0000
+++ accounts/sip/data/telephony-sip.provider	2017-04-05 14:05:16 +0000
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<provider id="telephony-sip">
+  <name>SIP</name>
+  <icon>sip</icon>
+</provider>
 
=== added directory 'accounts/sip/qml'
=== added file 'accounts/sip/qml/AccountInfo.qml'
=== added file 'accounts/sip/qml/CMakeLists.txt'
--- accounts/sip/qml/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ accounts/sip/qml/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -0,0 +1,13 @@
+file(GLOB QML_PLUGIN_FILES *.qml)
+
+# The path (including plug-in name) where the QML files are installed
+set(QML_PLUGIN_INSTALL_DIR share/accounts/qml-plugins/telephony-sip/)
+
+# Do not install symbolic links
+set (QML_PLUGIN_RESOLVED_FILES "")
+foreach (QML_PLUGIN_FILE ${QML_PLUGIN_FILES})
+    get_filename_component(resolvedFile "${QML_PLUGIN_FILE}" REALPATH)
+    list (APPEND QML_PLUGIN_RESOLVED_FILES "${resolvedFile}")
+endforeach()
+
+install(FILES ${QML_PLUGIN_RESOLVED_FILES} DESTINATION ${QML_PLUGIN_INSTALL_DIR})
 
=== added symlink 'accounts/sip/qml/DynamicField.qml'
=== target is u'../../common/DynamicField.qml'
=== added symlink 'accounts/sip/qml/Main.qml'
=== target is u'../../common/Main.qml'
=== added file 'accounts/sip/qml/NewAccount.qml'
--- accounts/sip/qml/NewAccount.qml	1970-01-01 00:00:00 +0000
+++ accounts/sip/qml/NewAccount.qml	2017-04-05 14:05:16 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Renato Araujo Oliveira Filho <[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/>.
+ */
+
+import QtQuick 2.0
+
+NewAccountInterface {
+    id: root 
+
+    manager: 'sofiasip'
+    protocol: 'sip'
+    icon: 'sip'
+    hasCrendentials: false
+    params: [
+        {'name': 'account', 'inputType': 'string', 'label': i18n.tr('Sip Id. (Eg: [e-mail])'), 'store': true},
+        {'name': 'password', 'inputType': 'password', 'label': i18n.tr('Password'), 'store': true}
+    ]
+    advancedParams: [
+        {'name': 'discover-stun', 'inputType': 'boolean', 'label': i18n.tr('Discover the STUN server automatically'), 'store': true, 'defaultValue' : 'false' },
+        {'name': 'stun-server', 'inputType': 'string', 'label': i18n.tr('STUN server'), 'store': true},
+        {'name': 'stun-port', 'inputType': 'numeric', 'label': i18n.tr('STUN port'), 'store': true},
+        {'name': 'discover-binding', 'inputType': 'boolean', 'label': i18n.tr('Divscover Binding'), 'store': true, 'defaultValue': 'true'},
+        {'name': 'proxy-host', 'inputType': 'string', 'label': i18n.tr('Proxy server'), 'store': true},
+        {'name': 'port', 'inputType': 'numeric', 'label': i18n.tr('Proxy port'), 'store': true},
+        {'name': 'keepalive-mechanism', 'inputType': 'string', 'label': i18n.tr('Keep alive mechanism'), 'store': true, 'defaultValue': 'auto'},
+        {'name': 'keepalive-interval', 'inputType': 'numeric', 'label': i18n.tr('Keep alive interval'), 'store': true},
+        {'name': 'auth-user', 'inputType': 'string', 'label': i18n.tr('Authentication username'), 'store': true},
+        {'name': 'transport', 'inputType': 'string', 'label': i18n.tr('Transport'), 'store': true, 'defaultValue': 'auto'},
+        {'name': 'loose-routing', 'inputType': 'boolean', 'label': i18n.tr('Loose Routing'), 'store': true, 'defaultValue': 'false'}
+    ]
+}
 
=== added symlink 'accounts/sip/qml/NewAccountInterface.qml'
=== target is u'../../common/NewAccountInterface.qml'
=== modified file 'approver/approver.cpp'
--- approver/approver.cpp	2016-11-23 19:28:18 +0000
+++ approver/approver.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2016 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Tiago Salem Herrmann <[e-mail]>
@@ -27,10 +27,12 @@
 #include "chatmanager.h"
 #include "config.h"
 #include "contactutils.h"
+#include "contactwatcher.h"
 #include "greetercontacts.h"
 #include "ringtone.h"
 #include "callmanager.h"
 #include "callentry.h"
+#include "protocol.h"
 #include "protocolmanager.h"
 #include "tonegenerator.h"
 #include "telepathyhelper.h"
@@ -315,11 +317,13 @@
 
     mChannels.remove(pr);
 
+    QString id = ContactWatcher::normalizeIdentifier(contact->id(), true);
+
     // and now set up the contact matching for either greeter mode or regular mode
     if (GreeterContacts::isGreeterMode()) {
         // show the snap decision right away because contact info might never arrive
         showSnapDecision(dispatchOp, channel);
-        GreeterContacts::instance()->setContactFilter(QContactPhoneNumber::match(contact->id()));
+        GreeterContacts::instance()->setContactFilter(QContactPhoneNumber::match(id));
     } else {
         AccountEntry *account = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
         if (!account) {
@@ -329,7 +333,7 @@
 
         // try to match the contact info
         QContactFetchRequest *request = new QContactFetchRequest(this);
-        request->setFilter(QContactPhoneNumber::match(contact->id()));
+        request->setFilter(QContactPhoneNumber::match(id));
 
         // lambda function to update the notification
         QObject::connect(request, &QContactAbstractRequest::stateChanged, [this, request, dispatchOp, channel](QContactAbstractRequest::State state) {
@@ -350,14 +354,9 @@
             showSnapDecision(dispatchOp, channel, contact);
         });
 
-        // FIXME: For accounts not based on phone numbers, don't try to match contacts for now
-        if (account->type() == AccountEntry::PhoneAccount) {
-            request->setManager(ContactUtils::sharedManager());
-            request->start();
-        } else {
-            // just emit the signal to pretend we did a contact search
-            Q_EMIT request->stateChanged(QContactAbstractRequest::FinishedState);
-        }
+        // FIXME: For accounts not based on phone numbers, check what to do
+        request->setManager(ContactUtils::sharedManager());
+        request->start();
     }
 }
 
@@ -440,42 +439,46 @@
     data->channel = channel;
     bool unknownNumber = false;
 
+    QString id = ContactWatcher::normalizeIdentifier(telepathyContact->id(), true);
+
     AccountEntry *account = TelepathyHelper::instance()->accountForConnection(channel->connection());
     if (!account) {
         qCritical() << "Call exists with no account for connection";
         return false;
     }
 
+    bool supportsText = (account->protocolInfo()->features() & Protocol::TextChats);
+
     mCachedBody = QString();
 
     if (account->type() == AccountEntry::PhoneAccount &&
             TelepathyHelper::instance()->multiplePhoneAccounts()) {
         mCachedBody = QString::fromUtf8(C::gettext("On [%1]")).arg(account->displayName());
         mCachedBody += "\n";
-        if (!telepathyContact->id().isEmpty()) {
-            if (telepathyContact->id().startsWith(OFONO_PRIVATE_NUMBER)) {
+        if (!id.isEmpty()) {
+            if (id.startsWith(OFONO_PRIVATE_NUMBER)) {
                 mCachedBody += QString::fromUtf8(C::gettext("Private number"));
                 unknownNumber = true;
-            } else if (telepathyContact->id().startsWith(OFONO_UNKNOWN_NUMBER)) {
+            } else if (id.startsWith(OFONO_UNKNOWN_NUMBER)) {
                 mCachedBody += QString::fromUtf8(C::gettext("Unknown number"));
                 unknownNumber = true;
             } else {
-                mCachedBody += telepathyContact->id();
+                mCachedBody += id;
             }
         } else {
             mCachedBody += C::gettext("Caller number is not available");
             unknownNumber = true;
         }
     } else {
-        if (!telepathyContact->id().isEmpty()) {
-            if (telepathyContact->id().startsWith(OFONO_PRIVATE_NUMBER)) {
+        if (!id.isEmpty()) {
+            if (id.startsWith(OFONO_PRIVATE_NUMBER)) {
                 mCachedBody = QString::fromUtf8(C::gettext("Calling from private number"));
                 unknownNumber = true;
-            } else if (telepathyContact->id().startsWith(OFONO_UNKNOWN_NUMBER)) {
+            } else if (id.startsWith(OFONO_UNKNOWN_NUMBER)) {
                 mCachedBody = QString::fromUtf8(C::gettext("Calling from unknown number"));
                 unknownNumber = true;
             } else {
-                mCachedBody = QString::fromUtf8(C::gettext("Calling from %1")).arg(telepathyContact->id());
+                mCachedBody = QString::fromUtf8(C::gettext("Calling from %1")).arg(id);
             }
         } else {
             mCachedBody = C::gettext("Caller number is not available");
@@ -544,7 +547,7 @@
                                     data,
                                     delete_event_data);
 
-    if (!unknownNumber) {
+    if (!unknownNumber && supportsText) {
         notify_notification_add_action(notification,
                                        "action_decline_expansion",
                                        C::gettext("Message & decline"),
 
=== modified file 'cmake/modules/GenerateTest.cmake'
--- cmake/modules/GenerateTest.cmake	2016-12-13 01:51:47 +0000
+++ cmake/modules/GenerateTest.cmake	2017-04-05 14:05:16 +0000
@@ -78,6 +78,7 @@
                                     MC_ACCOUNT_DIR=${TMPDIR}
                                     MC_MANAGER_DIR=${TMPDIR}
                                     MC_CLIENTS_DIR=${TMPDIR}
+                                    PA_DISABLED=1
                                     TELEPHONY_SERVICE_TEST=1
                                     TELEPHONY_SERVICE_PROTOCOLS_DIR=${CMAKE_SOURCE_DIR}/tests/common/protocols
                                     TEST_DATA_DIR=${CMAKE_SOURCE_DIR}/tests/common/data)
 
=== added file 'debian/account-plugin-irc-unity8.install'
--- debian/account-plugin-irc-unity8.install	1970-01-01 00:00:00 +0000
+++ debian/account-plugin-irc-unity8.install	2017-04-05 14:05:16 +0000
@@ -0,0 +1,3 @@
+usr/share/accounts/qml-plugins/telephony-irc/*
+usr/share/accounts/providers/telephony-irc.provider
+usr/share/accounts/services/telephony-irc-im.service
 
=== added file 'debian/account-plugin-sip-unity8.install'
--- debian/account-plugin-sip-unity8.install	1970-01-01 00:00:00 +0000
+++ debian/account-plugin-sip-unity8.install	2017-04-05 14:05:16 +0000
@@ -0,0 +1,3 @@
+usr/share/accounts/qml-plugins/telephony-sip/*
+usr/share/accounts/providers/telephony-sip.provider
+usr/share/accounts/services/telephony-sip-im.service
 
=== modified file 'debian/control'
--- debian/control	2016-12-05 15:14:33 +0000
+++ debian/control	2017-04-05 14:05:16 +0000
@@ -13,10 +13,12 @@
                libicu-dev,
                libmessaging-menu-dev,
                libnotify-dev,
+               libgsettings-qt-dev,
                libphonenumber-dev,
                libtelepathy-qt5-dev,
-               libubuntu-application-api-dev [armhf],
                libprotobuf-dev,
+               libpulse-dev,
+               liburl-dispatcher1-dev,
                pkg-config,
                python:any,
                qml-module-qttest,
@@ -92,3 +94,24 @@
  This package contains the QML plugin providing the features from the telephony
  PhoneNumber to applications.
 
+Package: account-plugin-sip-unity8
+Architecture: all
+Pre-Depends: dpkg (>= 1.15.6~)
+Depends: mcp-account-manager-uoa-common,
+         telepathy-accounts-signon,
+         telepathy-rakia
+Description: Online account plugin for unity8
+ Online account plugin for unity8.
+ .
+ This package contains the online account plugin providing sip account.
+
+Package: account-plugin-irc-unity8
+Architecture: all
+Pre-Depends: dpkg (>= 1.15.6~)
+Depends: mcp-account-manager-uoa-common,
+         mfw-plugin-irc
+Description: Online account plugin for unity8
+ Online account plugin for unity8.
+ .
+ This package contains the online account plugin providing irc account.
+
 
=== modified file 'handler/CMakeLists.txt'
--- handler/CMakeLists.txt	2016-12-06 16:45:01 +0000
+++ handler/CMakeLists.txt	2017-04-05 14:05:16 +0000
@@ -1,12 +1,24 @@
+if (PULSEAUDIO_FOUND)
+    add_definitions(-DUSE_PULSEAUDIO)
+    set(USE_PULSEAUDIO ON)
+    set(QPULSEAUDIOENGINE_CPP qpulseaudioengine.cpp)
+endif (PULSEAUDIO_FOUND)
 
 set(qt_SRCS
+    accountproperties.cpp
+    callagent.cpp
+    audioroutemanager.cpp
     callhandler.cpp
     chatstartingjob.cpp
+    farstreamchannel.cpp
     handler.cpp
     handlerdbus.cpp
     messagejob.cpp
     messagesendingjob.cpp
+    powerdaudiomodemediator.cpp
+    powerddbus.cpp
     texthandler.cpp
+    ${QPULSEAUDIOENGINE_CPP}
     )
 
 set(handler_SRCS main.cpp ${qt_SRCS})
@@ -16,8 +28,13 @@
 
 include_directories(
     ${TP_QT5_INCLUDE_DIRS}
+    ${TPFS_INCLUDE_DIRS}
+    ${FS_INCLUDE_DIRS}
+    ${GST_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}/libtelephonyservice
     ${CMAKE_CURRENT_BINARY_DIR}
+    ${GSETTINGS_QT_INCLUDE_DIRS}
+    ${PULSEAUDIO_INCLUDE_DIRS}
     )
 
 add_executable(telephony-service-handler ${handler_SRCS} ${handler_HDRS})
@@ -25,7 +42,11 @@
 
 target_link_libraries(telephony-service-handler
     ${TP_QT5_LIBRARIES}
+    ${TP_QT5_FS_LIBRARIES}
+    ${TPFS_LIBRARIES}
+    ${FS_LIBRARIES}
     telephonyservice
+    ${PULSEAUDIO_LIBRARIES}
     )
 
 enable_coverage(telephony-service-handler)
 
=== modified file 'handler/Handler.xml'
--- handler/Handler.xml	2016-12-06 16:45:01 +0000
+++ handler/Handler.xml	2017-04-05 14:05:16 +0000
@@ -114,13 +114,6 @@
             <arg name="objectPath" type="s" direction="in"/>
             <arg name="muted" type="b" direction="in"/>
         </method>
-        <method name="SetActiveAudioOutput">
-            <dox:d><![CDATA[
-                Change the current active audio output
-            ]]></dox:d>
-            <arg name="objectPath" type="s" direction="in"/>
-            <arg name="id" type="s" direction="in"/>
-        </method>
         <method name="SendDTMF">
             <dox:d><![CDATA[
                 Send a DTMF to the given channel
@@ -177,9 +170,48 @@
             <dox:d><![CDATA[
                 Get the list of current available protocols
             ]]></dox:d>
-            <arg name="result" type="a(sussss)" direction="out"/>
+            <arg name="result" type="a(susussbbssssbbbbbbb)" direction="out"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="ProtocolList"/>
         </method>
+        <method name="LeaveRooms">
+            <dox:d><![CDATA[
+                Close all rooms of a given account
+            ]]></dox:d>
+            <arg name="accountId" type="s" direction="in"/>
+            <arg name="message" type="s" direction="in"/>
+        </method>
+        <method name="GetAllAccountsProperties">
+            <dox:d><![CDATA[
+                Get the properties of all available accounts
+            ]]></dox:d>
+            <arg name="result" type="a{sa{sv}}" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="AllAccountsProperties"/>
+        </method>
+        <method name="GetAccountProperties">
+            <dox:d><![CDATA[
+                Get the properties of the given accountId
+            ]]></dox:d>
+            <arg name="accoundId" type="s" direction="in"/>
+            <arg name="result" type="a{sv}" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+        </method>
+        <method name="SetAccountProperties">
+            <dox:d><![CDATA[
+                Set the properties of the given accountId
+            ]]></dox:d>
+            <arg name="accoundId" type="s" direction="in"/>
+            <arg name="properties" type="a{sv}" direction="in"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
+        </method>
+        <signal name="AccountPropertiesChanged">
+            <dox:d><![CDATA[
+                The properties of a given account changed.
+            ]]></dox:d>
+            <arg name="accountId" type="s"/>
+            <arg name="properties" type="a{sv}"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="QVariantMap"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
+        </signal>
         <signal name="CallPropertiesChanged">
             <dox:d><![CDATA[
                 The properties of a given call changed.
@@ -213,9 +245,32 @@
             <dox:d><![CDATA[
                 The protocols files in protocols dir have changed
             ]]></dox:d>
-            <arg name="protocols" type="a(sussss)"/>
+            <arg name="protocols" type="a(susussbbssssbbbbbbb)"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="ProtocolList"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="ProtocolList"/>
         </signal>
+        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="true"/>
+        <property name="ActiveAudioOutput" type="s" access="readwrite"/>
+        <signal name="ActiveAudioOutputChanged">
+            <dox:d><![CDATA[
+                The active audio output has changed
+            ]]></dox:d>
+            <arg name="id" type="s"/>
+        </signal>
+        <method name="AudioOutputs">
+            <dox:d><![CDATA[
+            ]]></dox:d>
+            <arg name="outputs" type="a(sss)" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="AudioOutputDBusList"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="AudioOutputDBusList"/>
+        </method>
+        <signal name="AudioOutputsChanged">
+            <dox:d><![CDATA[
+                The available audio outputs have changed
+            ]]></dox:d>
+            <arg name="outputs" type="a(sss)"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="AudioOutputDBusList"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="AudioOutputDBusList"/>
+        </signal>
     </interface>
 </node>
 
=== modified file 'handler/TelephonyServiceHandler.client'
--- handler/TelephonyServiceHandler.client	2016-04-15 22:25:51 +0000
+++ handler/TelephonyServiceHandler.client	2017-04-05 14:05:16 +0000
@@ -6,3 +6,12 @@
 
 [org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 3]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Call1
+
+[org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 1]
+org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Call1
+org.freedesktop.Telepathy.Channel.Type.Call1.InitialAudio b=true
+
+[org.freedesktop.Telepathy.Client.Handler.Capabilities]
+org.freedesktop.Telepathy.Channel.Type.Call1/audio=true
+org.freedesktop.Telepathy.Channel.Type.Call1/ice=true
+org.freedesktop.Telepathy.Channel.Type.Call1/gtalk-p2p=true
 
=== added file 'handler/accountproperties.cpp'
--- handler/accountproperties.cpp	1970-01-01 00:00:00 +0000
+++ handler/accountproperties.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "accountproperties.h"
+#include "telepathyhelper.h"
+#include <QSettings>
+
+#define SETTINGS_DOMAIN "com.canonical.TelephonyServiceHandler"
+
+AccountProperties *AccountProperties::instance()
+{
+    static AccountProperties *self = new AccountProperties();
+    return self;
+}
+
+QMap<QString, QVariantMap> AccountProperties::allProperties()
+{
+    QMap<QString,QVariantMap> props;
+    for (auto accountId : TelepathyHelper::instance()->accountIds()) {
+        props[accountId] = accountProperties(accountId);
+    }
+}
+
+QVariantMap AccountProperties::accountProperties(const QString &accountId)
+{
+    QVariantMap props;
+    mSettings->beginGroup(formatAccountId(accountId));
+    for (auto key : mSettings->allKeys()) {
+        props[key] = mSettings->value(key);
+    }
+    mSettings->endGroup();
+    return props;
+}
+
+void AccountProperties::setAccountProperties(const QString &accountId, const QVariantMap &properties)
+{
+    mSettings->beginGroup(formatAccountId(accountId));
+    for (auto key : properties.keys()) {
+        mSettings->setValue(key, properties[key]);
+    }
+    mSettings->endGroup();
+}
+
+QString AccountProperties::formatAccountId(const QString &accountId)
+{
+    return QUrl::toPercentEncoding(accountId);
+}
+
+AccountProperties::AccountProperties(QObject *parent)
+: QObject(parent),
+  mSettings(new QSettings(SETTINGS_DOMAIN, QString(), parent))
+{
+}
 
=== added file 'handler/accountproperties.h'
--- handler/accountproperties.h	1970-01-01 00:00:00 +0000
+++ handler/accountproperties.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ACCOUNTPROPERTIES_H
+#define ACCOUNTPROPERTIES_H
+
+#include <QObject>
+
+class QSettings;
+
+class AccountProperties : public QObject
+{
+    Q_OBJECT
+public:
+    static AccountProperties *instance();
+
+    QMap<QString,QVariantMap> allProperties();
+    QVariantMap accountProperties(const QString &accountId);
+    void setAccountProperties(const QString &accountId, const QVariantMap &properties);
+    QString formatAccountId(const QString &accountId);
+
+protected:
+    explicit AccountProperties(QObject *parent = 0);
+
+private:
+    QSettings *mSettings;
+};
+
+#endif // ACCOUNTPROPERTIES_H
 
=== added file 'handler/audioroutemanager.cpp'
--- handler/audioroutemanager.cpp	1970-01-01 00:00:00 +0000
+++ handler/audioroutemanager.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "audioroutemanager.h"
+#include "telepathyhelper.h"
+#include "accountentry.h"
+#include <TelepathyQt/Contact>
+#include <TelepathyQt/Functors>
+
+
+static void enable_earpiece()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallActive, AudioModeBtOrWiredOrEarpiece);
+#endif
+}
+
+static void enable_normal()
+{
+#ifdef USE_PULSEAUDIO
+    QTimer* timer = new QTimer();
+    timer->setSingleShot(true);
+    QObject::connect(timer, &QTimer::timeout, [=](){
+        QPulseAudioEngine::instance()->setMicMute(false);
+        QPulseAudioEngine::instance()->setCallMode(CallEnded, AudioModeWiredOrSpeaker);
+        timer->deleteLater();
+    });
+    timer->start(2000);
+#endif
+}
+
+static void enable_speaker()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallActive, AudioModeSpeaker);
+#endif
+}
+
+static void enable_ringtone()
+{
+#ifdef USE_PULSEAUDIO
+    QPulseAudioEngine::instance()->setCallMode(CallRinging, AudioModeBtOrWiredOrSpeaker);
+#endif
+}
+
+AudioRouteManager *AudioRouteManager::instance()
+{
+    static AudioRouteManager *self = new AudioRouteManager();
+    return self;
+}
+
+AudioRouteManager::AudioRouteManager(QObject *parent) :
+    QObject(parent), mAudioModeMediator(mPowerDDBus)
+{
+    TelepathyHelper::instance()->registerChannelObserver("TelephonyServiceHandlerAudioRouteManager");
+
+    QObject::connect(TelepathyHelper::instance()->channelObserver(), SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
+                 this, SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
+
+#ifdef USE_PULSEAUDIO
+    // update audio modes
+    QObject::connect(QPulseAudioEngine::instance(), SIGNAL(audioModeChanged(AudioMode)), SLOT(onAudioModeChanged(AudioMode)));
+    QObject::connect(QPulseAudioEngine::instance(), SIGNAL(availableAudioModesChanged(AudioModes)), SLOT(onAvailableAudioModesChanged(AudioModes)));
+
+    // check if we should indeed use pulseaudio
+    QByteArray pulseAudioDisabled = qgetenv("PA_DISABLED");
+    mHasPulseAudio = true;
+    if (!pulseAudioDisabled.isEmpty())
+        mHasPulseAudio = false;
+#endif
+
+    connect(this, &AudioRouteManager::activeAudioOutputChanged, Tp::memFun(&mAudioModeMediator, &PowerDAudioModeMediator::audioModeChanged));
+    connect(this, &AudioRouteManager::lastChannelClosed, Tp::memFun(&mAudioModeMediator, &PowerDAudioModeMediator::audioOutputClosed));
+}
+
+void AudioRouteManager::onCallChannelAvailable(Tp::CallChannelPtr callChannel)
+{
+    connect(callChannel.data(),
+                SIGNAL(callStateChanged(Tp::CallState)),
+                SLOT(onCallStateChanged(Tp::CallState)));
+
+    mChannels.append(callChannel);
+    updateAudioRoute(true);
+}
+
+void AudioRouteManager::onCallStateChanged(Tp::CallState state)
+{
+    Tp::CallChannelPtr channel(qobject_cast<Tp::CallChannel*>(sender()));
+    if (!channel) {
+        return;
+    }
+
+    if (channel->callState() ==  Tp::CallStateEnded) {
+        mChannels.removeOne(channel);
+    }
+    updateAudioRoute(false);
+}
+
+void AudioRouteManager::setActiveAudioOutput(const QString &id)
+{
+#ifdef USE_PULSEAUDIO
+    // fallback to earpiece/headset
+    AudioMode mode = AudioModeWiredOrEarpiece;
+    if (id == "bluetooth") {
+        mode = AudioModeBluetooth;
+    } else if (id == "speaker") {
+        mode = AudioModeSpeaker;
+    }
+    if (mHasPulseAudio)
+        QPulseAudioEngine::instance()->setCallMode(CallActive, mode);
+#endif
+}
+
+QString AudioRouteManager::activeAudioOutput()
+{
+    return mActiveAudioOutput;
+}
+
+AudioOutputDBusList AudioRouteManager::audioOutputs() const
+{
+    return mAudioOutputs;
+}
+
+void AudioRouteManager::updateAudioRoute(bool newCall)
+{
+#ifdef USE_PULSEAUDIO
+    if (!mHasPulseAudio)
+        return;
+#endif
+
+    int currentCalls = mChannels.size();
+    if (currentCalls != 0) {
+        if (currentCalls == 1) {
+            // if we have only one call, check if it's incoming and
+            // enable speaker mode so the ringtone is audible
+            Tp::CallChannelPtr callChannel = mChannels.first();
+            AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
+            if (!accountEntry || !callChannel) {
+                return;
+            }
+
+            bool incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+            Tp::CallState state = callChannel->callState();
+            if (incoming && newCall) {
+                enable_ringtone();
+                return;
+            }
+            if (state == Tp::CallStateEnded) {
+                enable_normal();
+                return;
+            }
+            // if only one call and dialing, or incoming call just accepted, then default to earpiece
+            if (newCall || (state == Tp::CallStateAccepted && incoming)) {
+                enable_earpiece();
+                return;
+            }
+        }
+    } else {
+        enable_normal();
+        Q_EMIT lastChannelClosed();
+    }
+}
+
+#ifdef USE_PULSEAUDIO
+void AudioRouteManager::onAudioModeChanged(AudioMode mode)
+{
+    qDebug("PulseAudio audio mode changed: 0x%x", mode);
+
+    if (mode == AudioModeEarpiece && mActiveAudioOutput != "earpiece") {
+        mActiveAudioOutput = "earpiece";
+    } else if (mode == AudioModeWiredHeadset && mActiveAudioOutput != "wired_headset") {
+        mActiveAudioOutput = "wired_headset";
+    } else if (mode == AudioModeSpeaker && mActiveAudioOutput != "speaker") {
+        mActiveAudioOutput = "speaker";
+    } else if (mode == AudioModeBluetooth && mActiveAudioOutput != "bluetooth") {
+        mActiveAudioOutput = "bluetooth";
+    }
+    Q_EMIT activeAudioOutputChanged(mActiveAudioOutput);
+}
+
+void AudioRouteManager::onAvailableAudioModesChanged(AudioModes modes)
+{
+    qDebug("PulseAudio available audio modes changed");
+    bool defaultFound = false;
+    mAudioOutputs.clear();
+    Q_FOREACH(const AudioMode &mode, modes) {
+        AudioOutputDBus output;
+        if (mode == AudioModeBluetooth) {
+            // there can be only one bluetooth
+            output.id = "bluetooth";
+            output.type = "bluetooth";
+            // we dont support names for now, so we set a default value
+            output.name = "bluetooth";
+        } else if (mode == AudioModeEarpiece || mode == AudioModeWiredHeadset) {
+            if (!defaultFound) {
+                defaultFound = true;
+                output.id = "default";
+                output.type = "default";
+                output.name = "default";
+            } else {
+                continue;
+            }
+        } else if (mode == AudioModeSpeaker) {
+            output.id = "speaker";
+            output.type = "speaker";
+            output.name = "speaker";
+        }
+        mAudioOutputs << output;
+    }
+    Q_EMIT audioOutputsChanged(mAudioOutputs);
+}
+#endif
+
 
=== added file 'handler/audioroutemanager.h'
--- handler/audioroutemanager.h	1970-01-01 00:00:00 +0000
+++ handler/audioroutemanager.h	2017-04-05 14:05:16 +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
 
=== added file 'handler/callagent.cpp'
--- handler/callagent.cpp	1970-01-01 00:00:00 +0000
+++ handler/callagent.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "callagent.h"
+#include <TelepathyQt/CallContent>
+#include <TelepathyQt/Contact>
+#include <TelepathyQt/Farstream/Channel>
+#include <QDebug>
+
+CallAgent::CallAgent(const Tp::CallChannelPtr &channel, QObject *parent) :
+    QObject(parent), mChannel(channel), mFarstreamChannel(0)
+{
+    connect(mChannel.data(),
+            SIGNAL(invalidated(Tp::DBusProxy*,QString,QString)),
+            SLOT(onCallChannelInvalidated()));
+    connect(mChannel.data(),
+            SIGNAL(callStateChanged(Tp::CallState)),
+            SLOT(onCallStateChanged(Tp::CallState)));
+    connect(mChannel.data(),
+            SIGNAL(contentAdded(Tp::CallContentPtr)),
+            SLOT(onContentAdded(Tp::CallContentPtr)));
+
+    Q_FOREACH(const Tp::CallContentPtr &content, mChannel->contents()) {
+        onContentAdded(content);
+    }
+
+    if (!mChannel->handlerStreamingRequired()) {
+        return;
+    }
+
+    Tp::Farstream::PendingChannel *pendingChannel = Tp::Farstream::createChannel(mChannel);
+    connect(pendingChannel,
+            SIGNAL(finished(Tp::PendingOperation*)),
+            SLOT(onFarstreamChannelCreated(Tp::PendingOperation*)));
+}
+
+CallAgent::~CallAgent()
+{
+    if (mFarstreamChannel) {
+        mFarstreamChannel->deleteLater();
+    }
+}
+
+void CallAgent::setMute(bool mute)
+{
+    if (!mFarstreamChannel) {
+        return;
+    }
+
+    mFarstreamChannel->setMute(mute);
+}
+
+void CallAgent::onCallChannelInvalidated()
+{
+    deleteLater();
+}
+
+void CallAgent::onCallStateChanged(Tp::CallState state)
+{
+    if (state == Tp::CallStatePendingInitiator) {
+        mChannel->accept();
+    }
+}
+
+void CallAgent::onContentAdded(const Tp::CallContentPtr &content)
+{
+    if (!mChannel->handlerStreamingRequired()) {
+        return;
+    }
+
+    qDebug() << "Content Added, name: " << content->name() << " type: " << content->type();
+
+    connect(content.data(),
+            SIGNAL(streamAdded(Tp::CallStreamPtr)),
+            SLOT(onStreamAdded(Tp::CallStreamPtr)));
+
+    Q_FOREACH(const Tp::CallStreamPtr &stream, content->streams()) {
+        onStreamAdded(stream);
+    }
+}
+
+void CallAgent::onStreamAdded(const Tp::CallStreamPtr &stream)
+{
+    qDebug() << "Stream present: " << stream->localSendingState();
+
+    qDebug() << "  members " << stream->remoteMembers().size();
+    Q_FOREACH(const Tp::ContactPtr contact, stream->remoteMembers()) {
+        qDebug() << "    member " << contact->id() << " remoteSendingState=" << stream->remoteSendingState(contact);
+    }
+}
+
+void CallAgent::onFarstreamChannelCreated(Tp::PendingOperation *op)
+{
+    Tp::Farstream::PendingChannel *pendingChannel = qobject_cast<Tp::Farstream::PendingChannel*>(op);
+    if (!pendingChannel) {
+        return;
+    }
+
+    mFarstreamChannel = new FarstreamChannel(pendingChannel->tfChannel(), this);
+}
 
=== added file 'handler/callagent.h'
--- handler/callagent.h	1970-01-01 00:00:00 +0000
+++ handler/callagent.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CALLAGENT_H
+#define CALLAGENT_H
+
+#include <QObject>
+#include <TelepathyQt/CallChannel>
+#include <TelepathyQt/Farstream/Channel>
+#include "farstreamchannel.h"
+
+class CallAgent : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CallAgent(const Tp::CallChannelPtr &channel, QObject *parent = 0);
+    ~CallAgent();
+
+    void setMute(bool mute);
+
+protected Q_SLOTS:
+    void onCallChannelInvalidated();
+    void onCallStateChanged(Tp::CallState state);
+    void onContentAdded(const Tp::CallContentPtr &content);
+    void onStreamAdded(const Tp::CallStreamPtr &stream);
+
+    void onFarstreamChannelCreated(Tp::PendingOperation *op);
+
+private:
+    Tp::CallChannelPtr mChannel;
+    FarstreamChannel *mFarstreamChannel;
+};
+
+#endif // CALLAGENT_H
 
=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2015-07-06 23:32:13 +0000
+++ handler/callhandler.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2014 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -20,15 +20,19 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "accountproperties.h"
+#include "callagent.h"
 #include "callhandler.h"
-#include "phoneutils.h"
 #include "telepathyhelper.h"
 #include "accountentry.h"
 #include "tonegenerator.h"
 #include "greetercontacts.h"
+#include "phoneutils.h"
 #include <TelepathyQt/ContactManager>
 #include <TelepathyQt/PendingContacts>
 #include <TelepathyQt/PendingChannelRequest>
+#include <TelepathyQt/PendingVariant>
+#include <memory>
 
 #define TELEPATHY_MUTE_IFACE "org.freedesktop.Telepathy.Call1.Interface.Mute"
 #define DBUS_PROPERTIES_IFACE "org.freedesktop.DBus.Properties"
@@ -72,8 +76,7 @@
     bool hasActiveCalls = false;
 
     Q_FOREACH(const Tp::CallChannelPtr channel, mCallChannels) {
-        AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(channel->connection());
-        bool incoming = channel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+        bool incoming = isIncoming(channel);
         bool dialing = !incoming && (channel->callState() == Tp::CallStateInitialised);
         bool active = channel->callState() == Tp::CallStateActive;
 
@@ -94,6 +97,7 @@
 
 void CallHandler::startCall(const QString &targetId, const QString &accountId)
 {
+    QString finalId = targetId;
     // Request the contact to start audio call
     AccountEntry *accountEntry = TelepathyHelper::instance()->accountForId(accountId);
     if (!accountEntry) {
@@ -105,7 +109,24 @@
         return;
     }
 
-    connect(connection->contactManager()->contactsForIdentifiers(QStringList() << targetId),
+    // FIXME: this is a workaround, there might be a better way of handling this.
+    // One idea is to implement the Addressing interface on the SIP connection manager such that
+    // we can request a handle based on the vCard field "tel"
+    if (accountEntry->protocolInfo()->name() == "sip") {
+        // check if the phone number needs rewriting
+        QVariantMap accountProperties = AccountProperties::instance()->accountProperties(accountId);
+        finalId = applyNumberRewritingRules(finalId, accountProperties);
+
+        // replace the numbers by a SIP URI
+        QString domain = accountEntry->account()->parameters()["account"].toString();
+        if (domain.contains("@")) {
+            domain = domain.split("@")[1];
+
+            finalId = QString("sip:%1@%2").arg(PhoneUtils::normalizePhoneNumber(finalId)).arg(domain);
+        }
+    }
+
+    connect(connection->contactManager()->contactsForIdentifiers(QStringList() << finalId),
             SIGNAL(finished(Tp::PendingOperation*)),
             SLOT(onContactsAvailable(Tp::PendingOperation*)));
 }
@@ -146,41 +167,30 @@
         return;
     }
 
-    // FIXME: replace by a proper TpQt implementation of mute
-    QDBusInterface muteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE);
-    muteInterface.call("RequestMuted", muted);
-}
-
-void CallHandler::setActiveAudioOutput(const QString &objectPath, const QString &id)
-{
-    Tp::CallChannelPtr channel = callFromObjectPath(objectPath);
-
-    QDBusInterface audioOutputsInterface(channel->busName(), channel->objectPath(), CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
-    audioOutputsInterface.call("SetActiveAudioOutput", id);
+    if (channel->handlerStreamingRequired()) {
+        CallAgent *agent = mCallAgents[channel.data()];
+        if (!agent) {
+            return;
+        }
+        agent->setMute(muted);
+    } else {
+        // FIXME: replace by a proper TpQt implementation of mute
+        QDBusInterface muteInterface(channel->busName(), channel->objectPath(), TELEPATHY_MUTE_IFACE);
+        muteInterface.call("RequestMuted", muted);
+    }
 }
 
 void CallHandler::sendDTMF(const QString &objectPath, const QString &key)
 {
-    bool ok;
-    Tp::DTMFEvent event = (Tp::DTMFEvent)key.toInt(&ok);
-    if (!ok) {
-         if (!key.compare("*")) {
-             event = Tp::DTMFEventAsterisk;
-         } else if (!key.compare("#")) {
-             event = Tp::DTMFEventHash;
-         } else {
-             qWarning() << "Tone not recognized. DTMF failed";
-             return;
-         }
-    }
     /*
-     * play locally (via tone generator) only if we are on a call, or if this is 
+     * play locally (via tone generator) only if we are on a call, or if this is
      * dialpad sounds
      */
-    if (GreeterContacts::instance()->dialpadSoundsEnabled() && 
+    int event = toDTMFEvent(key);
+    if (GreeterContacts::instance()->dialpadSoundsEnabled() &&
         !GreeterContacts::instance()->silentMode() && objectPath.isEmpty()
         || !objectPath.isEmpty()) {
-        ToneGenerator::instance()->playDTMFTone((uint)event);
+        ToneGenerator::instance()->playDTMFTone(event);
     }
 
     Tp::CallChannelPtr channel = callFromObjectPath(objectPath);
@@ -190,14 +200,15 @@
 
     // save the dtmfString to send to clients that request it
     QString dtmfString = channel->property("dtmfString").toString();
+    QString pendingDTMF = channel->property("pendingDTMF").toString();
+    pendingDTMF += key;
     dtmfString += key;
     channel->setProperty("dtmfString", dtmfString);
+    channel->setProperty("pendingDTMF", pendingDTMF);
 
-    Q_FOREACH(const Tp::CallContentPtr &content, channel->contents()) {
-        if (content->supportsDTMF()) {
-            /* send DTMF to network (via telepathy and oFono) */
-            content->startDTMFTone(event);
-        }
+    // if there is only one pending DTMF event, start playing it
+    if (pendingDTMF.length() == 1) {
+        playNextDTMFTone(channel);
     }
 
     Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
@@ -266,13 +277,12 @@
 void CallHandler::onCallChannelAvailable(Tp::CallChannelPtr channel)
 {
     QDBusInterface callChannelIface(channel->busName(), channel->objectPath(), DBUS_PROPERTIES_IFACE);
-    QDBusMessage reply = callChannelIface.call("GetAll", CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
-    QVariantList args = reply.arguments();
-    QMap<QString, QVariant> map = qdbus_cast<QMap<QString, QVariant> >(args[0]);
     channel->setProperty("timestamp", QDateTime::currentDateTimeUtc());
 
     if (channel->callState() == Tp::CallStateActive) {
         channel->setProperty("activeTimestamp", QDateTime::currentDateTimeUtc());
+    } else if (channel->callState() == Tp::CallStatePendingInitiator) {
+        channel->accept();
     }
 
     connect(channel.data(),
@@ -282,6 +292,10 @@
             SIGNAL(callStateChanged(Tp::CallState)),
             SLOT(onCallStateChanged(Tp::CallState)));
 
+    // FIXME: save this to a list
+    CallAgent *agent = new CallAgent(channel, this);
+    mCallAgents[channel.data()] = agent;
+
     mCallChannels.append(channel);
     Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
 }
@@ -331,7 +345,12 @@
     }
 
     mCallChannels.removeAll(channel);
+    if (mCallAgents.contains(channel.data())) {
+        CallAgent *agent = mCallAgents.take(channel.data());
+        agent->deleteLater();
+    }
 
+    ToneGenerator::instance()->stopTone();
     if (mCallChannels.isEmpty() && !mHangupRequested) {
         ToneGenerator::instance()->playCallEndedTone();
     }
@@ -346,10 +365,29 @@
     }
 
     switch (state) {
+    case Tp::CallStatePendingInitiator:
+    case Tp::CallStateInitialising:
+        if (!isIncoming(channel) && channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->playDialingTone();
+        }
+        break;
+    case Tp::CallStateInitialised:
+        if (!isIncoming(channel) && channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->stopTone();
+            ToneGenerator::instance()->playRingingTone();
+        }
+        break;
     case Tp::CallStateActive:
+        if (channel->handlerStreamingRequired()) {
+            ToneGenerator::instance()->stopTone();
+        }
         channel->setProperty("activeTimestamp", QDateTime::currentDateTimeUtc());
         Q_EMIT callPropertiesChanged(channel->objectPath(), getCallProperties(channel->objectPath()));
         break;
+    case Tp::CallStateEnded:
+        ToneGenerator::instance()->stopTone();
+        channel->requestClose();
+        break;
     }
 }
 
@@ -387,3 +425,128 @@
 
     return channel;
 }
+
+void CallHandler::playNextDTMFTone(Tp::CallChannelPtr channel)
+{
+    // the channel might have been closed already
+    if (!channel) {
+        return;
+    }
+
+    QString pendingDTMF = channel->property("pendingDTMF").toString();
+    QString key = "";
+    if (!pendingDTMF.isEmpty()) {
+        key = pendingDTMF[0];
+    }
+
+    int event = toDTMFEvent(key);
+
+    Q_FOREACH(const Tp::CallContentPtr &content, channel->contents()) {
+        if (content->supportsDTMF()) {
+
+            /* stop any previous DTMF tone before sending the new one*/
+            connect(content->stopDTMFTone(), &Tp::PendingOperation::finished, [=](Tp::PendingOperation *op){
+                // in case stopDTMFTone, it might mean the service automatically stops the tone,
+                // so try playing the next one
+                if (op->isError()) {
+                    /* send DTMF to network (via telepathy) */
+                    if (event >= 0) {
+                        content->startDTMFTone((Tp::DTMFEvent)event);
+                    }
+                    triggerNextDTMFTone(channel);
+                    return;
+                }
+
+                Tp::Client::CallContentInterfaceDTMFInterface *dtmfInterface = content->interface<Tp::Client::CallContentInterfaceDTMFInterface>();
+                Tp::PendingVariant *pv = dtmfInterface->requestPropertyCurrentlySendingTones();
+                connect(pv, &Tp::PendingOperation::finished, [=](){
+                    bool sendingTones = pv->result().toBool();
+                    // if we already stopped sending tones, we can send the next one
+                    if (!sendingTones) {
+                        /* send DTMF to network (via telepathy) */
+                        if (event >= 0) {
+                            content->startDTMFTone((Tp::DTMFEvent)event);
+                        }
+                        triggerNextDTMFTone(channel);
+                        return;
+                    }
+
+                    // in case the previous tone is not finished, we need to wait for it
+                    auto conn = std::make_shared<QMetaObject::Connection>();
+                    *conn = connect(dtmfInterface, &Tp::Client::CallContentInterfaceDTMFInterface::StoppedTones, [=](){
+                        QObject::disconnect(*conn);
+
+                        /* send DTMF to network (via telepathy) */
+                        if (event >= 0) {
+                            content->startDTMFTone((Tp::DTMFEvent)event);
+                        }
+                        triggerNextDTMFTone(channel);
+                    });
+                });
+
+            });
+        }
+    }
+}
+
+void CallHandler::triggerNextDTMFTone(Tp::CallChannelPtr channel)
+{
+    QTimer::singleShot(250, [=](){
+        QString pendingDTMF = channel->property("pendingDTMF").toString();
+        if (pendingDTMF.isEmpty()) {
+            return;
+        }
+        pendingDTMF.remove(0, 1);
+        channel->setProperty("pendingDTMF", pendingDTMF);
+        playNextDTMFTone(channel);
+    });
+}
+
+int CallHandler::toDTMFEvent(const QString &key)
+{
+    bool ok;
+    int ev = key.toInt(&ok);
+    if (!ok) {
+         if (key == "*") {
+             ev = Tp::DTMFEventAsterisk;
+         } else if (key == "#") {
+             ev = Tp::DTMFEventHash;
+         } else {
+             ev = -1;
+         }
+    }
+    return ev;
+}
+
+bool CallHandler::isIncoming(const Tp::CallChannelPtr &channel) const
+{
+    AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(channel->connection());
+    return channel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+}
+
+QString CallHandler::applyNumberRewritingRules(const QString &originalNumber, const QVariantMap &properties)
+{
+    QString finalNumber = originalNumber;
+    if (properties.contains("numberRewrite") && properties["numberRewrite"].toBool()) {
+        // FIXME: do a proper phone number identification implementation
+        // for now consider anything bigger than 6 digits to be a phone number
+        if (finalNumber.length() <= 6) {
+            return finalNumber;
+        }
+
+        QString defaultCountryCode = properties["defaultCountryCode"].toString();
+        QString defaultAreaCode = properties["defaultAreaCode"].toString();
+        QString removeCharacters = properties["removeCharacters"].toString();
+        QString prefix = properties["prefix"].toString();
+
+        if (!defaultCountryCode.startsWith("+")) {
+            defaultCountryCode.prepend("+");
+        }
+
+        finalNumber = PhoneUtils::getFullNumber(finalNumber, defaultCountryCode, defaultAreaCode);
+        finalNumber.remove(removeCharacters);
+        finalNumber.prepend(prefix);
+    }
+
+    return finalNumber;
+}
 
=== modified file 'handler/callhandler.h'
--- handler/callhandler.h	2015-03-04 18:02:13 +0000
+++ handler/callhandler.h	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2013 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -28,6 +28,7 @@
 #include <TelepathyQt/CallChannel>
 
 class TelepathyHelper;
+class CallAgent;
 
 class CallHandler : public QObject
 {
@@ -44,7 +45,6 @@
     void hangUpCall(const QString &objectPath);
     void setHold(const QString &objectPath, bool hold);
     void setMuted(const QString &objectPath, bool muted);
-    void setActiveAudioOutput(const QString &objectPath, const QString &id);
     void sendDTMF(const QString &objectPath, const QString &key);
 
     // conference call related
@@ -61,6 +61,13 @@
     Tp::CallChannelPtr existingCall(const QString &targetId);
     Tp::CallChannelPtr callFromObjectPath(const QString &objectPath);
 
+    void playNextDTMFTone(Tp::CallChannelPtr channel);
+    void triggerNextDTMFTone(Tp::CallChannelPtr channel);
+    static int toDTMFEvent(const QString &key);
+    bool isIncoming(const Tp::CallChannelPtr &channel) const;
+
+    QString applyNumberRewritingRules(const QString &originalNumber, const QVariantMap &properties);
+
 protected Q_SLOTS:
     void onContactsAvailable(Tp::PendingOperation *op);
     void onCallHangupFinished(Tp::PendingOperation *op);
@@ -72,6 +79,7 @@
 
     QMap<QString, Tp::ContactPtr> mContacts;
     QList<Tp::CallChannelPtr> mCallChannels;
+    QMap<Tp::CallChannel*,CallAgent*> mCallAgents;
     QMap<Tp::PendingOperation*,Tp::CallChannelPtr> mClosingChannels;
     bool mHangupRequested;
 };
 
=== added file 'handler/farstreamchannel.cpp'
--- handler/farstreamchannel.cpp	1970-01-01 00:00:00 +0000
+++ handler/farstreamchannel.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,326 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "farstreamchannel.h"
+#include <farstream/fs-utils.h>
+#include <QDebug>
+
+FarstreamChannel::FarstreamChannel(TfChannel *channel, QObject *parent) :
+    mChannel(channel), QObject(parent), mPipeline(0), mBus(0), mBusSource(0),
+    mConferenceAddedSignal(0), mConferenceRemovedSignal(0), mContentAddedSignal(0),
+    mContentRemovedSignal(0), mAudioInput(0), mAudioOutput(0)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    initialize();
+}
+
+FarstreamChannel::~FarstreamChannel()
+{
+    // stop audio input and output
+    if (mAudioInput) {
+        setState(mAudioInput, GST_STATE_NULL);
+        gst_object_unref(mAudioInput);
+    }
+
+    if (mAudioOutput) {
+        setState(mAudioOutput, GST_STATE_NULL);
+        gst_object_unref(mAudioOutput);
+    }
+
+    // now clear the notifiers
+    Q_FOREACH(FsElementAddedNotifier *notifier, mNotifiers) {
+        fs_element_added_notifier_remove(notifier, GST_BIN(mPipeline));
+        g_object_unref(notifier);
+    }
+    mNotifiers.clear();
+
+    // clear the bus stuff
+    if (mBusSource) {
+        g_source_remove(mBusSource);
+    }
+
+    if (mBus) {
+        gst_object_unref(mBus);
+    }
+
+    // and finally the pipeline
+    if (mPipeline) {
+        setState(mPipeline, GST_STATE_NULL);
+        gst_object_unref(mPipeline);
+    }
+}
+
+void FarstreamChannel::setMute(bool mute)
+{
+    GstElement *input_volume = gst_bin_get_by_name(GST_BIN(mPipeline), "input_volume");
+    g_object_set(input_volume, "mute", mute, NULL);
+    g_object_unref(input_volume);
+}
+
+void FarstreamChannel::initialize()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // connect all the signals
+    mConferenceAddedSignal = g_signal_connect(mChannel, "fs-conference-added",
+                                              G_CALLBACK(&FarstreamChannel::onConferenceAdded),
+                                              this);
+    mConferenceRemovedSignal = g_signal_connect(mChannel, "fs-conference-removed",
+                                                G_CALLBACK(&FarstreamChannel::onConferenceRemoved),
+                                                this);
+    mContentAddedSignal = g_signal_connect(mChannel, "content-added",
+                                           G_CALLBACK(&FarstreamChannel::onContentAdded),
+                                           this);
+    mContentRemovedSignal = g_signal_connect(mChannel, "content-removed",
+                                             G_CALLBACK(&FarstreamChannel::onContentRemoved),
+                                             this);
+
+    // and initialize the gstreamer pipeline
+    mPipeline = gst_pipeline_new(NULL);
+    if (!mPipeline) {
+        qCritical() << "Failed to create GStreamer pipeline.";
+        return;
+    }
+
+    mBus = gst_pipeline_get_bus(GST_PIPELINE(mPipeline));
+    if (!mBus) {
+        qCritical() << "Failed to get GStreamer pipeline bus.";
+        return;
+    }
+
+    mBusSource = gst_bus_add_watch(mBus, (GstBusFunc) &FarstreamChannel::onBusWatch, this);
+
+    if (!setState(mPipeline, GST_STATE_PLAYING)) {
+        return;
+    }
+}
+
+GstElement *FarstreamChannel::initializeAudioSource(TfContent *content)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    GstElement *element = gst_parse_bin_from_description ("alsasrc ! audio/x-raw, rate=8000 ! queue"
+                                                          " ! audioconvert ! audioresample"
+                                                          " ! volume name=input_volume ! audioconvert ",
+                                                          TRUE, NULL);
+    gint input_volume = 0;
+    g_object_get (content, "requested-input-volume", &input_volume, NULL);
+
+    if (input_volume >= 0) {
+        GstElement *volume = gst_bin_get_by_name (GST_BIN (element), "input_volume");
+        g_object_set (volume, "volume", (double)input_volume / 255.0, NULL);
+        gst_object_unref (volume);
+    }
+
+    // FIXME: we probably need to handle input volume request changes
+    mAudioOutput = element;
+    return element;
+}
+
+bool FarstreamChannel::addToPipeline(GstElement *element)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element);
+    if (!mPipeline) {
+        qWarning() << "No gstreamer pipeline found.";
+        return false;
+    }
+
+    if (!gst_bin_add(GST_BIN(mPipeline), element)) {
+        qCritical() << "Failed to add bin" << GST_ELEMENT_NAME(element) << "to pipeline.";
+        return false;
+    }
+    qDebug() << "Succeeded adding to pipeline!";
+    return true;
+}
+
+void FarstreamChannel::removeFromPipeline(GstElement *element)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element);
+    gst_element_set_locked_state(element, TRUE);
+    setState(element, GST_STATE_NULL);
+    gst_bin_remove (GST_BIN (mPipeline), element);
+}
+
+bool FarstreamChannel::setState(GstElement *element, GstState state)
+{
+    qDebug() << __PRETTY_FUNCTION__ << GST_ELEMENT_NAME(element) << gst_element_state_get_name(state);
+    GstStateChangeReturn result = gst_element_set_state(element, state);
+    if (result == GST_STATE_CHANGE_FAILURE) {
+        qCritical() << "Failed to set GStreamer element" << GST_ELEMENT_NAME(element) << "state to" << gst_element_state_get_name(state);
+        return false;
+    }
+    qDebug() << "Succeeded playing!";
+    return true;
+}
+
+gboolean FarstreamChannel::onBusWatch(GstBus *bus, GstMessage *message, FarstreamChannel *self)
+{
+    Q_UNUSED(bus)
+    if (!self->mChannel) {
+        return TRUE;
+    }
+
+    // FIXME: maybe we need to do some error handling here?
+    tf_channel_bus_message(self->mChannel, message);
+    return TRUE;
+}
+
+void FarstreamChannel::onConferenceAdded(TfChannel *channel, FsConference *conference, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel)
+
+    /* Add notifier to set the various element properties as needed */
+    GKeyFile *keyfile = fs_utils_get_default_element_properties (GST_ELEMENT(conference));
+    if (keyfile != NULL) {
+        qDebug() << "Loaded default properties for" << GST_ELEMENT_NAME(conference);
+        FsElementAddedNotifier *notifier = fs_element_added_notifier_new();
+        fs_element_added_notifier_set_properties_from_keyfile(notifier, keyfile);
+        fs_element_added_notifier_add(notifier, GST_BIN(self->mPipeline));
+
+        // FIXME: right now we are leaking the notifiers, check when to remove them
+        self->mNotifiers.append(notifier);
+    }
+
+    if (!self->addToPipeline(GST_ELEMENT(conference))) {
+        return;
+    }
+
+    self->setState(GST_ELEMENT(conference), GST_STATE_PLAYING);
+}
+
+void FarstreamChannel::onConferenceRemoved(TfChannel *channel, FsConference *conference, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel);
+
+    // just remove the conference from the pipeline
+    self->removeFromPipeline(GST_ELEMENT(conference));
+}
+
+void FarstreamChannel::onContentAdded(TfChannel *channel, TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(channel)
+
+    g_signal_connect(content, "src-pad-added",
+                     G_CALLBACK(&FarstreamChannel::onSrcPadAdded), self);
+    g_signal_connect(content, "start-sending",
+                     G_CALLBACK(&FarstreamChannel::onStartSending), self);
+    g_signal_connect(content, "stop-sending",
+                     G_CALLBACK(&FarstreamChannel::onStopSending), self);
+}
+
+void FarstreamChannel::onContentRemoved(TfChannel *channel, TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // FIXME: implement
+}
+
+bool FarstreamChannel::onStartSending(TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    GstPad *sinkPad;
+    FsMediaType mediaType;
+    GstElement *element;
+
+    g_object_get (content, "sink-pad", &sinkPad, "media-type", &mediaType, NULL);
+
+    switch (mediaType) {
+    case FS_MEDIA_TYPE_AUDIO:
+        element = self->initializeAudioSource(content);
+        break;
+    // FIXME: add video support
+    default:
+        qWarning() << "Unsupported media type:" << mediaType;
+        g_object_unref(sinkPad);
+        return false;
+    }
+
+    if (!self->addToPipeline(element)) {
+        g_object_unref(sinkPad);
+        return false;
+    }
+
+    GstPad *sourcePad = gst_element_get_static_pad (element, "src");
+    if (GST_PAD_LINK_FAILED (gst_pad_link (sourcePad, sinkPad))) {
+        qCritical() << "Failed to link source pad to content's sink pad";
+        g_object_unref(sinkPad);
+        g_object_unref(sourcePad);
+        return false;
+    }
+
+    self->setState(element, GST_STATE_PLAYING);
+    self->mAudioInput = element;
+
+    g_object_unref(sinkPad);
+    g_object_unref(sourcePad);
+
+    return true;
+}
+
+void FarstreamChannel::onStopSending(TfContent *content, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    // FIXME: implement
+}
+
+void FarstreamChannel::onSrcPadAdded(TfContent *content, uint handle, FsStream *stream, GstPad *pad, FsCodec *codec, FarstreamChannel *self)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    gchar *codecString = fs_codec_to_string (codec);
+    qDebug() << __PRETTY_FUNCTION__ << "Codec:" << codecString;
+
+    FsMediaType mediaType;
+    GstElement *element;
+
+    g_object_get (content, "media-type", &mediaType, NULL);
+
+    switch (mediaType) {
+    case FS_MEDIA_TYPE_AUDIO: {
+         QString outputVolume = QString("output_volume%1").arg(codecString);
+         QString description = QString("audioconvert ! audioresample "
+                                       "! volume name=\"%1\" "
+                                       "! audioconvert ! autoaudiosink").arg(outputVolume);
+         element = gst_parse_bin_from_description (description.toUtf8().data(), TRUE, NULL);
+         GstElement *volume = gst_bin_get_by_name (GST_BIN (element), outputVolume.toUtf8().data());
+
+         // FIXME: we need to handle volume request changes in the volume element
+         gst_object_unref (volume);
+         break;
+    }
+    // FIXME: handle video
+    default:
+        qWarning() << "Unsupported media type:" << mediaType;
+        return;
+    }
+
+    if (!self->addToPipeline(element)) {
+        return;
+    }
+
+    GstPad *sinkPad = gst_element_get_static_pad (element, "sink");
+    if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sinkPad))) {
+        qCritical() << "Failed to link content's source pad to local sink pad";
+    }
+
+    self->setState(element, GST_STATE_PLAYING);
+
+    g_object_unref (sinkPad);
+}
 
=== added file 'handler/farstreamchannel.h'
--- handler/farstreamchannel.h	1970-01-01 00:00:00 +0000
+++ handler/farstreamchannel.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef FARSTREAMCHANNEL_H
+#define FARSTREAMCHANNEL_H
+
+#include <QObject>
+#include <QList>
+#include <telepathy-farstream/telepathy-farstream.h>
+#include <farstream/fs-conference.h>
+#include <farstream/fs-stream.h>
+#include <farstream/fs-element-added-notifier.h>
+
+class FarstreamChannel : public QObject
+{
+    Q_OBJECT
+public:
+    explicit FarstreamChannel(TfChannel *channel, QObject *parent = 0);
+    ~FarstreamChannel();
+
+    void setMute(bool mute);
+
+protected:
+    void initialize();
+    GstElement *initializeAudioSource(TfContent *content);
+
+    // gstreamer helpers
+    bool addToPipeline(GstElement *element);
+    void removeFromPipeline(GstElement *bin);
+    bool setState(GstElement *element, GstState state);
+
+    // glib signal handlers
+    static gboolean onBusWatch(GstBus *bus, GstMessage *message, FarstreamChannel *self);
+    static void onConferenceAdded(TfChannel *channel, FsConference *conference, FarstreamChannel *self);
+    static void onConferenceRemoved(TfChannel *channel, FsConference *conference, FarstreamChannel *self);
+    static void onContentAdded(TfChannel *channel, TfContent * content, FarstreamChannel *self);
+    static void onContentRemoved(TfChannel *channel, TfContent * content, FarstreamChannel *self);
+    static bool onStartSending(TfContent *content, FarstreamChannel *self);
+    static void onStopSending(TfContent *content, FarstreamChannel *self);
+    static void onSrcPadAdded(TfContent *content, uint handle, FsStream *stream, GstPad *pad, FsCodec *codec, FarstreamChannel *self);
+
+private:
+    TfChannel *mChannel;
+
+    // gstreamer stuff
+    GstElement *mPipeline;
+    GstBus *mBus;
+    uint mBusSource;
+    GstElement *mAudioInput;
+    GstElement *mAudioOutput;
+
+    // signal IDs
+    gulong mConferenceAddedSignal;
+    gulong mConferenceRemovedSignal;
+    gulong mContentAddedSignal;
+    gulong mContentRemovedSignal;
+
+    // farstream stuff
+    QList<FsElementAddedNotifier*> mNotifiers;
+};
+
+#endif // FARSTREAMCHANNEL_H
 
=== modified file 'handler/handler.cpp'
--- handler/handler.cpp	2016-11-23 19:28:18 +0000
+++ handler/handler.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2016 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Tiago Salem Herrmann <[e-mail]>
@@ -32,7 +32,7 @@
 #include <TelepathyQt/PendingReady>
 
 Handler::Handler(QObject *parent)
-    : QObject(parent), Tp::AbstractClientHandler(channelFilters())
+    : QObject(parent), Tp::AbstractClientHandler(channelFilters(), capabilities())
 {
 }
 
@@ -102,9 +102,22 @@
     specList << Tp::ChannelClassSpec::textChatroom();
     specList << Tp::ChannelClassSpec::unnamedTextChat();
 
+    QVariantMap props;
+    props[TP_QT_IFACE_CHANNEL_TYPE_CALL + ".InitialAudio"] = true;
+    specList << Tp::ChannelClassSpec::audioCall(props);
+
     return specList;
 }
 
+Tp::AbstractClientHandler::Capabilities Handler::capabilities()
+{
+    QStringList caps;
+    caps << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/shm"
+         << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/ice"
+         << TP_QT_IFACE_CHANNEL_TYPE_CALL + "/gtalk-p2p";
+    return Tp::AbstractClientHandler::Capabilities(caps);
+}
+
 void Handler::onTextChannelReady(Tp::PendingOperation *op)
 {
     Tp::PendingReady *pr = qobject_cast<Tp::PendingReady*>(op);
@@ -155,10 +168,12 @@
     // if the call is neither Accepted nor Active, it means it got dispatched directly to the handler without passing
     // through any approver. For phone calls, this would mean calls getting auto-accepted which is not desirable
     // so we return an error here
-    bool incoming = false;
+    bool incoming = !callChannel->isRequested();
     AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
-    if (accountEntry) {
-        incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+    if (accountEntry &&
+        !callChannel->initiatorContact().isNull() &&
+        callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact()) {
+        incoming = true;
     }
     if (incoming && callChannel->callState() != Tp::CallStateAccepted && callChannel->callState() != Tp::CallStateActive) {
         qWarning() << "Available channel was not approved by telephony-service-approver, ignoring it.";
 
=== modified file 'handler/handler.h'
--- handler/handler.h	2015-07-01 22:04:30 +0000
+++ handler/handler.h	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2013 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Tiago Salem Herrmann <[e-mail]>
@@ -45,6 +45,7 @@
                         const QDateTime &userActionTime,
                         const Tp::AbstractClientHandler::HandlerInfo &handlerInfo);
     Tp::ChannelClassSpecList channelFilters();
+    Tp::AbstractClientHandler::Capabilities capabilities();
 
 Q_SIGNALS:
     void textChannelAvailable(Tp::TextChannelPtr textChannel);
 
=== modified file 'handler/handlerdbus.cpp'
--- handler/handlerdbus.cpp	2016-12-06 16:45:01 +0000
+++ handler/handlerdbus.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2016 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Ugo Riboni <[e-mail]>
@@ -21,6 +21,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "accountproperties.h"
+#include "audiooutput.h"
+#include "audioroutemanager.h"
 #include "callhandler.h"
 #include "handlerdbus.h"
 #include "handleradaptor.h"
@@ -53,6 +56,12 @@
             &ProtocolManager::protocolsChanged, [this]() {
                 Q_EMIT ProtocolsChanged(ProtocolManager::instance()->protocols().dbusType());
             });
+    connect(AudioRouteManager::instance(),
+            SIGNAL(audioOutputsChanged(AudioOutputDBusList)),
+            SIGNAL(AudioOutputsChanged(AudioOutputDBusList)));
+    connect(AudioRouteManager::instance(),
+            SIGNAL(activeAudioOutputChanged(QString)),
+            SIGNAL(ActiveAudioOutputChanged(QString)));
 }
 
 HandlerDBus::~HandlerDBus()
@@ -95,6 +104,21 @@
     return ProtocolManager::instance()->protocols().dbusType();
 }
 
+AllAccountsProperties HandlerDBus::GetAllAccountsProperties()
+{
+    return AccountProperties::instance()->allProperties();
+}
+
+QVariantMap HandlerDBus::GetAccountProperties(const QString &accountId)
+{
+    return AccountProperties::instance()->accountProperties(accountId);
+}
+
+void HandlerDBus::SetAccountProperties(const QString &accountId, const QVariantMap &properties)
+{
+    AccountProperties::instance()->setAccountProperties(accountId, properties);
+}
+
 QString HandlerDBus::registerObject(QObject *object, const QString &path)
 {
     QString fullPath = QString("%1/%2").arg(DBUS_OBJECT_PATH, path);
@@ -125,6 +149,11 @@
     TextHandler::instance()->removeParticipants(objectPath, participants, message);
 }
 
+void HandlerDBus::LeaveRooms(const QString &accountId, const QString &message)
+{
+    return TextHandler::instance()->leaveRooms(accountId, message);
+}
+
 bool HandlerDBus::LeaveChat(const QString &objectPath, const QString &message)
 {
     return TextHandler::instance()->leaveChat(objectPath, message);
@@ -140,6 +169,21 @@
     return TextHandler::instance()->changeRoomTitle(objectPath, title);
 }
 
+void HandlerDBus::setActiveAudioOutput(const QString &id)
+{
+    AudioRouteManager::instance()->setActiveAudioOutput(id);
+}
+
+QString HandlerDBus::activeAudioOutput() const
+{
+    return AudioRouteManager::instance()->activeAudioOutput();
+}
+
+AudioOutputDBusList HandlerDBus::AudioOutputs() const
+{
+    return AudioRouteManager::instance()->audioOutputs();
+}
+
 bool HandlerDBus::connectToBus()
 {
     new TelephonyServiceHandlerAdaptor(this);
@@ -187,11 +231,6 @@
     CallHandler::instance()->setMuted(objectPath, muted);
 }
 
-void HandlerDBus::SetActiveAudioOutput(const QString &objectPath, const QString &id)
-{
-    CallHandler::instance()->setActiveAudioOutput(objectPath, id);
-}
-
 void HandlerDBus::SendDTMF(const QString &objectPath, const QString &key)
 {
     CallHandler::instance()->sendDTMF(objectPath, key);
 
=== modified file 'handler/handlerdbus.h'
--- handler/handlerdbus.h	2016-12-06 16:45:01 +0000
+++ handler/handlerdbus.h	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2016 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Ugo Riboni <[e-mail]>
@@ -28,6 +28,9 @@
 #include <QtDBus/QDBusContext>
 #include "chatmanager.h"
 #include "dbustypes.h"
+#include "audiooutput.h"
+
+typedef QMap<QString,QVariantMap> AllAccountsProperties;
 
 /**
  * DBus interface for the phone handler
@@ -40,6 +43,11 @@
                WRITE setCallIndicatorVisible
                NOTIFY CallIndicatorVisibleChanged)
 
+    Q_PROPERTY(QString ActiveAudioOutput
+               READ activeAudioOutput
+               WRITE setActiveAudioOutput
+               NOTIFY ActiveAudioOutputChanged)
+
 public:
     HandlerDBus(QObject* parent=0);
     ~HandlerDBus();
@@ -52,11 +60,16 @@
     void setCallIndicatorVisible(bool visible);
     // configuration related
     ProtocolList GetProtocols();
+    AllAccountsProperties GetAllAccountsProperties();
+    QVariantMap GetAccountProperties(const QString &accountId);
+    void SetAccountProperties(const QString &accountId, const QVariantMap &properties);
 
     QString registerObject(QObject *object, const QString &path);
     void unregisterObject(const QString &path);
 
     static HandlerDBus *instance();
+    QString activeAudioOutput() const;
+    void setActiveAudioOutput(const QString &id);
 
 public Q_SLOTS:
     bool connectToBus();
@@ -71,27 +84,33 @@
     Q_NOREPLY void InviteParticipants(const QString &objectPath, const QStringList &participants, const QString &message);
     Q_NOREPLY void RemoveParticipants(const QString &objectPath, const QStringList &participants, const QString &message);
     bool LeaveChat(const QString &objectPath, const QString &message);
+    Q_NOREPLY void LeaveRooms(const QString &accountId, const QString &message);
 
     // call related
     Q_NOREPLY void StartCall(const QString &number, const QString &accountId);
     Q_NOREPLY void HangUpCall(const QString &objectPath);
     Q_NOREPLY void SetHold(const QString &objectPath, bool hold);
     Q_NOREPLY void SetMuted(const QString &objectPath, bool muted);
-    Q_NOREPLY void SetActiveAudioOutput(const QString &objectPath, const QString &id);
     Q_NOREPLY void SendDTMF(const QString &objectPath, const QString &key);
 
     // conference call related
     Q_NOREPLY void CreateConferenceCall(const QStringList &objectPaths);
     Q_NOREPLY void MergeCall(const QString &conferenceObjectPath, const QString &callObjectPath);
     Q_NOREPLY void SplitCall(const QString &objectPath);
+    AudioOutputDBusList AudioOutputs() const;
+
+
 
 Q_SIGNALS:
     void onMessageSent(const QString &number, const QString &message);
     void CallPropertiesChanged(const QString &objectPath, const QVariantMap &properties);
+    void AccountPropertiesChanged(const QString &accountId, const QVariantMap &properties);
     void CallIndicatorVisibleChanged(bool visible);
     void ConferenceCallRequestFinished(bool succeeded);
     void CallHoldingFailed(const QString &objectPath);
     void ProtocolsChanged(const ProtocolList &protocols);
+    void ActiveAudioOutputChanged(const QString &id);
+    void AudioOutputsChanged(const AudioOutputDBusList &audioOutputs);
 
 private:
     bool mCallIndicatorVisible;
 
=== modified file 'handler/main.cpp'
--- handler/main.cpp	2016-11-23 19:28:18 +0000
+++ handler/main.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *    Gustavo Pichorim Boiko <[e-mail]>
@@ -30,6 +30,10 @@
 #include <TelepathyQt/AbstractClient>
 #include <TelepathyQt/AccountManager>
 #include <TelepathyQt/Contact>
+#include <telepathy-farstream/telepathy-farstream.h>
+#include <TelepathyQt/CallChannel>
+
+Q_DECLARE_METATYPE(Tp::CallChannelPtr)
 
 int main(int argc, char **argv)
 {
@@ -37,6 +41,13 @@
     QCoreApplication::setApplicationName("telephony-service-handler");
 
     Tp::registerTypes();
+    gst_init(&argc, &argv);
+    qRegisterMetaType<Tp::CallChannelPtr>();
+    qRegisterMetaType<AudioOutputDBus>();
+    qRegisterMetaType<AudioOutputDBusList>();
+
+    qDBusRegisterMetaType<AudioOutputDBus>();
+    qDBusRegisterMetaType<AudioOutputDBusList>();
 
     // check if there is already an instance of the handler running
     if (ApplicationUtils::checkApplicationRunning(TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler")) {
@@ -44,11 +55,13 @@
         return 1;
     }
 
+    HandlerDBus dbus;
     Handler *handler = new Handler();
-    QObject::connect(TelepathyHelper::instance(), &TelepathyHelper::setupReady, [handler]() {
+    QObject::connect(TelepathyHelper::instance(), &TelepathyHelper::setupReady, [&]() {
         TelepathyHelper::instance()->registerClient(handler, "TelephonyServiceHandler");
+        dbus.connectToBus();
     });
- 
+
     QObject::connect(handler, SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
                      CallHandler::instance(), SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
     QObject::connect(handler, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
 
=== added file 'handler/powerd.h'
--- handler/powerd.h	1970-01-01 00:00:00 +0000
+++ handler/powerd.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef POWERD_H
+#define POWERD_H
+
+class PowerD
+{
+public:
+    PowerD() = default;
+    virtual ~PowerD() = default;
+    PowerD(PowerD const&) = delete;
+    PowerD& operator=(PowerD const&) = delete;
+
+    virtual void enableProximityHandling() = 0;
+    virtual void disableProximityHandling() = 0;
+};
+
+#endif // POWERD_H
 
=== added file 'handler/powerdaudiomodemediator.cpp'
--- handler/powerdaudiomodemediator.cpp	1970-01-01 00:00:00 +0000
+++ handler/powerdaudiomodemediator.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#include <QDBusInterface>
+#include "powerdaudiomodemediator.h"
+
+PowerDAudioModeMediator::PowerDAudioModeMediator(PowerD &powerd)
+    : powerd(powerd)
+{
+}
+
+void PowerDAudioModeMediator::audioModeChanged(const QString &mode)
+{
+    bool enableProximity = !(mode == "speaker" || mode == "bluetooth" || mode == "wired_headset");
+
+    if (mProximityEnabled != enableProximity)
+    {
+        mProximityEnabled = enableProximity;
+        apply();
+    }
+}
+
+void PowerDAudioModeMediator::apply() const
+{
+    if (mProximityEnabled) {
+        powerd.enableProximityHandling();
+    } else {
+        // we need to power the screen on before disabling the proximity handling
+        QDBusInterface unityIface("com.canonical.Unity.Screen",
+                                  "/com/canonical/Unity/Screen",
+                                  "com.canonical.Unity.Screen",
+                                  QDBusConnection::systemBus());
+        QList<QVariant> args;
+        args.append("on");
+        args.append(3);
+        unityIface.callWithArgumentList(QDBus::NoBlock, "setScreenPowerMode", args);
+        powerd.disableProximityHandling();
+    }
+}
+
+void PowerDAudioModeMediator::audioOutputClosed()
+{
+    if (mProximityEnabled)
+    {
+        mProximityEnabled = false;
+        apply();
+    }
+}
 
=== added file 'handler/powerdaudiomodemediator.h'
--- handler/powerdaudiomodemediator.h	1970-01-01 00:00:00 +0000
+++ handler/powerdaudiomodemediator.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,46 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd.
+**
+** Authors:
+**  Andreas Pokorny <[e-mail]>
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#ifndef POWERDAUDIOMODEMEDIATOR_H
+#define POWERDAUDIOMODEMEDIATOR_H
+
+#include "powerd.h"
+
+#include <QString>
+#include <fstream>
+#include <memory>
+
+class PowerD;
+/*!
+ * \brief PowerDAudioModeMediator is responsible for configuring proximity
+ * handling of powerd during different call states and used audio outputs.
+ * In General that mean enabling sreen blanking on proximity events, when
+ * a call is active and neither a bluetooth headset nor the speakers are used.
+ */
+class PowerDAudioModeMediator
+{
+public:
+    PowerDAudioModeMediator(PowerD &powerd);
+    void audioModeChanged(const QString &mode);
+    void audioOutputClosed();
+private:
+    void apply() const;
+    PowerD &powerd;
+    bool mProximityEnabled{false};
+};
+
+#endif
 
=== added file 'handler/powerddbus.cpp'
--- handler/powerddbus.cpp	1970-01-01 00:00:00 +0000
+++ handler/powerddbus.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#include "powerddbus.h"
+
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+
+PowerDDBus::PowerDDBus()
+    : mPowerDIface{
+        new QDBusInterface(
+            "com.canonical.powerd",
+            "/com/canonical/powerd",
+            "com.canonical.powerd",
+            QDBusConnection::systemBus())}
+{
+}
+
+void PowerDDBus::enableProximityHandling()
+{
+    mPowerDIface->call("enableProximityHandling", "telephony-service-handler");
+}
+
+void PowerDDBus::disableProximityHandling()
+{
+    mPowerDIface->call("disableProximityHandling", "telephony-service-handler");
+}
 
=== added file 'handler/powerddbus.h'
--- handler/powerddbus.h	1970-01-01 00:00:00 +0000
+++ handler/powerddbus.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef POWERD_DUBS_H
+#define POWERD_DBUS_H
+
+#include "powerd.h"
+
+#include <memory>
+
+class QDBusInterface;
+
+class PowerDDBus : public PowerD
+{
+public:
+    PowerDDBus();
+    void enableProximityHandling() override;
+    void disableProximityHandling() override;
+private:
+    std::unique_ptr<QDBusInterface> mPowerDIface;
+};
+
+#endif
 
=== added file 'handler/qpulseaudioengine.cpp'
--- handler/qpulseaudioengine.cpp	1970-01-01 00:00:00 +0000
+++ handler/qpulseaudioengine.cpp	2017-04-05 14:05:16 +0000
@@ -0,0 +1,853 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file was taken from qt5 and modified by 
+** David Henningsson <[e-mail]> for usage in 
+** telepathy-ofono.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#include <QtCore/qdebug.h>
+
+#include "qpulseaudioengine.h"
+#include <sys/types.h>
+#include <unistd.h>
+
+#define PULSEAUDIO_PROFILE_HSP "headset_head_unit"
+#define PULSEAUDIO_PROFILE_A2DP "a2dp_sink"
+
+QT_BEGIN_NAMESPACE
+
+static void contextStateCallbackInit(pa_context *context, void *userdata)
+{
+    Q_UNUSED(context);
+    QPulseAudioEngineWorker *pulseEngine = reinterpret_cast<QPulseAudioEngineWorker*>(userdata);
+    pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+}
+
+static void contextStateCallback(pa_context *context, void *userdata)
+{
+    Q_UNUSED(userdata);
+    Q_UNUSED(context);
+}
+
+static void success_cb(pa_context *context, int success, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = reinterpret_cast<QPulseAudioEngineWorker*>(userdata);
+    pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+}
+
+/* Callbacks used when handling events from PulseAudio */
+static void plug_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->plugCardCallback(info);
+}
+
+static void update_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->updateCardCallback(info);
+}
+
+static void unplug_card_cb(pa_context *c, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (!pulseEngine) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+
+    if (info == NULL) {
+        /* That means that the card used to query card_info was removed */
+        pulseEngine->unplugCardCallback();
+    }
+}
+
+static void subscribeCallback(pa_context *context, pa_subscription_event_type_t t, uint32_t idx, void *userdata)
+{
+    /* For card change events (slot plug/unplug and add/remove card) */
+    if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_CARD) {
+        if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_CHANGE) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_CHANGE), Q_ARG(unsigned int, idx));
+        } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_NEW), Q_ARG(unsigned int, idx));
+        } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+            QMetaObject::invokeMethod((QPulseAudioEngineWorker *) userdata, "handleCardEvent",
+                    Qt::QueuedConnection, Q_ARG(int, PA_SUBSCRIPTION_EVENT_REMOVE), Q_ARG(unsigned int, idx));
+        }
+    }
+}
+
+QPulseAudioEngineWorker::QPulseAudioEngineWorker(QObject *parent)
+    : QObject(parent)
+    , m_mainLoopApi(0)
+    , m_context(0)
+    , m_callstatus(CallEnded)
+    , m_audiomode(AudioModeSpeaker)
+    , m_micmute(false)
+    , m_defaultsink("sink.primary")
+    , m_defaultsource("source.primary")
+    , m_voicecallcard("")
+    , m_voicecallhighest("")
+    , m_voicecallprofile("")
+    , m_bt_hsp("")
+    , m_bt_hsp_a2dp("")
+    , m_default_bt_card_fallback("")
+
+{
+    m_mainLoop = pa_threaded_mainloop_new();
+    if (m_mainLoop == 0) {
+        qWarning("Unable to create pulseaudio mainloop");
+        return;
+    }
+
+    if (pa_threaded_mainloop_start(m_mainLoop) != 0) {
+        qWarning("Unable to start pulseaudio mainloop");
+        pa_threaded_mainloop_free(m_mainLoop);
+        m_mainLoop = 0;
+        return;
+    }
+
+    createPulseContext();
+}
+
+bool QPulseAudioEngineWorker::createPulseContext()
+{
+    bool keepGoing = true;
+    bool ok = true;
+
+    if (m_context)
+        return true;
+
+    m_mainLoopApi = pa_threaded_mainloop_get_api(m_mainLoop);
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    m_context = pa_context_new(m_mainLoopApi, QString(QLatin1String("QtmPulseContext:%1")).arg(::getpid()).toLatin1().constData());
+    pa_context_set_state_callback(m_context, contextStateCallbackInit, this);
+
+    if (!m_context) {
+        qWarning("Unable to create new pulseaudio context");
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        return false;
+    }
+
+    if (pa_context_connect(m_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) {
+        qWarning("Unable to create a connection to the pulseaudio context");
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        releasePulseContext();
+        return false;
+    }
+
+    pa_threaded_mainloop_wait(m_mainLoop);
+
+    while (keepGoing) {
+        switch (pa_context_get_state(m_context)) {
+            case PA_CONTEXT_CONNECTING:
+            case PA_CONTEXT_AUTHORIZING:
+            case PA_CONTEXT_SETTING_NAME:
+                break;
+
+            case PA_CONTEXT_READY:
+                qDebug("Pulseaudio connection established.");
+                keepGoing = false;
+                break;
+
+            case PA_CONTEXT_TERMINATED:
+                qCritical("Pulseaudio context terminated.");
+                keepGoing = false;
+                ok = false;
+                break;
+
+            case PA_CONTEXT_FAILED:
+            default:
+                qCritical() << QString("Pulseaudio connection failure: %1").arg(pa_strerror(pa_context_errno(m_context)));
+                keepGoing = false;
+                ok = false;
+        }
+
+        if (keepGoing) {
+            pa_threaded_mainloop_wait(m_mainLoop);
+        }
+    }
+
+    if (ok) {
+        pa_context_set_state_callback(m_context, contextStateCallback, this);
+        pa_context_set_subscribe_callback(m_context, subscribeCallback, this);
+        pa_context_subscribe(m_context, PA_SUBSCRIPTION_MASK_CARD, NULL, this);
+    } else {
+        if (m_context) {
+            pa_context_unref(m_context);
+            m_context = 0;
+        }
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+    return true;
+}
+
+
+void QPulseAudioEngineWorker::releasePulseContext()
+{
+    if (m_context) {
+        pa_threaded_mainloop_lock(m_mainLoop);
+        pa_context_disconnect(m_context);
+        pa_context_unref(m_context);
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        m_context = 0;
+    }
+
+}
+
+QPulseAudioEngineWorker::~QPulseAudioEngineWorker()
+{
+    releasePulseContext();
+
+    if (m_mainLoop) {
+        pa_threaded_mainloop_stop(m_mainLoop);
+        pa_threaded_mainloop_free(m_mainLoop);
+        m_mainLoop = 0;
+    }
+}
+
+void QPulseAudioEngineWorker::cardInfoCallback(const pa_card_info *info)
+{
+    pa_card_profile_info2 *voice_call = NULL, *highest = NULL;
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+
+    /* For now we only support one card with the voicecall feature */
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!highest || info->profiles2[i]->priority > highest->priority)
+            highest = info->profiles2[i];
+        if (!strcmp(info->profiles2[i]->name, "voicecall"))
+            voice_call = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP) &&
+                 info->profiles2[i]->available != 0)
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) &&
+                 info->profiles2[i]->available != 0)
+            a2dp = info->profiles2[i];
+    }
+
+    /* Record the card that supports voicecall (default one to be used) */
+    if (voice_call) {
+        qDebug("Found card that supports voicecall: '%s'", info->name);
+        m_voicecallcard = info->name;
+        m_voicecallhighest = highest->name;
+    qDebug("1");
+        m_voicecallprofile = voice_call->name;
+    qDebug("2");
+    }
+
+    /* Handle the use cases needed for bluetooth */
+    if (hsp && a2dp) {
+        qDebug("Found card that supports hsp and a2dp: '%s'", info->name);
+        m_bt_hsp_a2dp = info->name;
+    } else if (hsp && (a2dp == NULL)) {
+        /* This card only provides the hsp profile */
+        qDebug("Found card that supports only hsp: '%s'", info->name);
+        m_bt_hsp = info->name;
+    }
+    qDebug("3");
+}
+
+void QPulseAudioEngineWorker::sinkInfoCallback(const pa_sink_info *info)
+{
+    pa_sink_port_info *earpiece = NULL, *speaker = NULL;
+    pa_sink_port_info *wired_headset = NULL, *wired_headphone = NULL;
+    pa_sink_port_info *preferred = NULL;
+    pa_sink_port_info *bluetooth_sco = NULL;
+    pa_sink_port_info *speaker_and_wired_headphone = NULL;
+    AudioMode audiomodetoset;
+    AudioModes modes;
+
+    for (int i = 0; i < info->n_ports; i++) {
+        if (!strcmp(info->ports[i]->name, "output-earpiece"))
+            earpiece = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-wired_headset") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headset = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-wired_headphone") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headphone = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-speaker"))
+            speaker = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-bluetooth_sco"))
+            bluetooth_sco = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "output-speaker+wired_headphone"))
+            speaker_and_wired_headphone = info->ports[i];
+    }
+
+    if (!earpiece || !speaker)
+        return; /* Not the right sink */
+
+    /* Refresh list of available audio modes */
+    modes.append(AudioModeEarpiece);
+    modes.append(AudioModeSpeaker);
+    if (wired_headset || wired_headphone)
+        modes.append(AudioModeWiredHeadset);
+    if (bluetooth_sco && ((m_bt_hsp != "") || (m_bt_hsp_a2dp != "")))
+        modes.append(AudioModeBluetooth);
+
+    /* Check if the requested mode is available (earpiece*/
+    if (((m_audiomode == AudioModeWiredHeadset) && !modes.contains(AudioModeWiredHeadset)) ||
+            ((m_audiomode == AudioModeBluetooth) && !modes.contains(AudioModeBluetooth)))
+        return;
+
+    /* Now to decide which output to be used, depending on the active mode */
+    if (m_audiomode & AudioModeEarpiece) {
+        preferred = earpiece;
+        audiomodetoset = AudioModeEarpiece;
+    }
+    if (m_audiomode & AudioModeSpeaker) {
+        preferred = speaker;
+        audiomodetoset = AudioModeSpeaker;
+    }
+    if ((m_audiomode & AudioModeWiredHeadset) && (modes.contains(AudioModeWiredHeadset))) {
+        preferred = wired_headset ? wired_headset : wired_headphone;
+        audiomodetoset = AudioModeWiredHeadset;
+    }
+    if (m_callstatus == CallRinging && speaker_and_wired_headphone) {
+        preferred = speaker_and_wired_headphone;
+    }
+    if ((m_audiomode & AudioModeBluetooth) && (modes.contains(AudioModeBluetooth))) {
+        preferred = bluetooth_sco;
+        audiomodetoset = AudioModeBluetooth;
+    }
+
+    m_audiomode = audiomodetoset;
+
+    m_nametoset = info->name;
+    if (info->active_port != preferred)
+        m_valuetoset = preferred->name;
+
+    if (modes != m_availableAudioModes)
+        m_availableAudioModes = modes;
+}
+
+void QPulseAudioEngineWorker::sourceInfoCallback(const pa_source_info *info)
+{
+    pa_source_port_info *builtin_mic = NULL, *preferred = NULL;
+    pa_source_port_info *wired_headset = NULL, *bluetooth_sco = NULL;
+
+    if (info->monitor_of_sink != PA_INVALID_INDEX)
+        return;  /* Not the right source */
+
+    for (int i = 0; i < info->n_ports; i++) {
+        if (!strcmp(info->ports[i]->name, "input-builtin_mic"))
+            builtin_mic = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "input-wired_headset") &&
+                (info->ports[i]->available != PA_PORT_AVAILABLE_NO))
+            wired_headset = info->ports[i];
+        else if (!strcmp(info->ports[i]->name, "input-bluetooth_sco_headset"))
+            bluetooth_sco = info->ports[i];
+    }
+
+    if (!builtin_mic)
+        return; /* Not the right source */
+
+    /* Now to decide which output to be used, depending on the active mode */
+    if ((m_audiomode & AudioModeEarpiece) || (m_audiomode & AudioModeSpeaker))
+        preferred = builtin_mic;
+    if ((m_audiomode & AudioModeWiredHeadset) && (m_availableAudioModes.contains(AudioModeWiredHeadset)))
+        preferred = wired_headset ? wired_headset : builtin_mic;
+    if ((m_audiomode & AudioModeBluetooth) && (m_availableAudioModes.contains(AudioModeBluetooth)))
+        preferred = bluetooth_sco;
+
+    m_nametoset = info->name;
+    if (info->active_port != preferred)
+        m_valuetoset = preferred->name;
+}
+
+void QPulseAudioEngineWorker::serverInfoCallback(const pa_server_info *info)
+{
+    /* Saving default sink/source to restore after call hangup */
+    m_defaultsink = info->default_sink_name;
+    m_defaultsource = info->default_source_name;
+
+    /* In the case of a server callback we need to signal the mainloop */
+    pa_threaded_mainloop_signal(mainloop(), 0);
+}
+
+static void cardinfo_cb(pa_context *context, const pa_card_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->cardInfoCallback(info);
+}
+
+static void sinkinfo_cb(pa_context *context, const pa_sink_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->sinkInfoCallback(info);
+}
+
+static void sourceinfo_cb(pa_context *context, const pa_source_info *info, int isLast, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (isLast != 0 || !pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->sourceInfoCallback(info);
+}
+
+static void serverinfo_cb(pa_context *context, const pa_server_info *info, void *userdata)
+{
+    QPulseAudioEngineWorker *pulseEngine = static_cast<QPulseAudioEngineWorker*>(userdata);
+    if (!pulseEngine || !info) {
+        pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
+        return;
+    }
+    pulseEngine->serverInfoCallback(info);
+}
+
+bool QPulseAudioEngineWorker::handleOperation(pa_operation *operation, const char *func_name)
+{
+    if (!operation) {
+        qCritical("'%s' failed (lost PulseAudio connection?)", func_name);
+        /* Free resources so it can retry a new connection during next operation */
+        pa_threaded_mainloop_unlock(m_mainLoop);
+        releasePulseContext();
+        return false;
+    }
+
+    while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING)
+        pa_threaded_mainloop_wait(m_mainLoop);
+    pa_operation_unref(operation);
+    return true;
+}
+
+int QPulseAudioEngineWorker::setupVoiceCall()
+{
+    pa_operation *o;
+
+    qDebug("Setting up pulseaudio for voice call");
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* Get and set the default sink/source to be restored later */
+    o = pa_context_get_server_info(m_context, serverinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_server_info"))
+        return -1;
+
+    qDebug("Recorded default sink: %s default source: %s",
+            m_defaultsink.c_str(), m_defaultsource.c_str());
+
+    /* Walk through the list of devices, find the voice call capable card and
+     * identify if we have bluetooth capable devices (hsp and a2dp) */
+    m_voicecallcard = m_voicecallhighest = m_voicecallprofile = "";
+    m_bt_hsp = m_bt_hsp_a2dp = "";
+    o = pa_context_get_card_info_list(m_context, cardinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_card_info_list"))
+        return -1;
+    /* In case we have only one bt device that provides hsp and a2dp, we need
+     * to make sure we switch the default profile for that card (to hsp) */
+    if ((m_bt_hsp_a2dp != "") && (m_bt_hsp == "")) {
+        qDebug("Setting PulseAudio card '%s' profile '%s'",
+                m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_HSP);
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_HSP, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return -1;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+
+    return 0;
+}
+
+void QPulseAudioEngineWorker::restoreVoiceCall()
+{
+    pa_operation *o;
+
+    qDebug("Restoring pulseaudio previous state");
+
+    /* Then restore previous settings */
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* See if we need to restore any HSP+AD2P device state */
+    if ((m_bt_hsp_a2dp != "") && (m_bt_hsp == "")) {
+        qDebug("Restoring PulseAudio card '%s' to profile '%s'",
+                m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_A2DP);
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_bt_hsp_a2dp.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    }
+
+    /* Restore default sink/source */
+    if (m_defaultsink != "") {
+        qDebug("Restoring PulseAudio default sink to '%s'", m_defaultsink.c_str());
+        o = pa_context_set_default_sink(m_context, m_defaultsink.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_sink"))
+            return;
+    }
+    if (m_defaultsource != "") {
+        qDebug("Restoring PulseAudio default source to '%s'", m_defaultsource.c_str());
+        o = pa_context_set_default_source(m_context, m_defaultsource.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_source"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+}
+
+void QPulseAudioEngineWorker::setCallMode(CallStatus callstatus, AudioMode audiomode)
+{
+    if (!createPulseContext()) {
+       return;
+    }
+    CallStatus p_callstatus = m_callstatus;
+    AudioMode p_audiomode = m_audiomode;
+    AudioModes p_availableAudioModes = m_availableAudioModes;
+    pa_operation *o;
+
+    /* Check if we need to save the current pulseaudio state (e.g. when starting a call) */
+    if ((callstatus != CallEnded) && (p_callstatus == CallEnded)) {
+        if (setupVoiceCall() < 0) {
+            qCritical("Failed to setup PulseAudio for Voice Call");
+            return;
+        }
+    }
+
+    /* If we have an active call, update internal state (used later when updating sink/source ports) */
+    m_callstatus = callstatus;
+    m_audiomode = audiomode;
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    /* Switch the virtual card mode when call is active and not active
+     * This needs to be done before sink/source gets updated, because after changing mode
+     * it will automatically move to input/output-parking */
+    if ((m_callstatus == CallActive) && (p_callstatus != CallActive) &&
+            (m_voicecallcard != "") && (m_voicecallprofile != "")) {
+        qDebug("Setting PulseAudio card '%s' profile '%s'",
+                m_voicecallcard.c_str(), m_voicecallprofile.c_str());
+        o = pa_context_set_card_profile_by_name(m_context,
+                m_voicecallcard.c_str(), m_voicecallprofile.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    } else if ((m_callstatus == CallEnded) && (m_voicecallcard != "") && (m_voicecallhighest != "")) {
+        /* If using droid, make sure to restore to the profile that has the highest score */
+        qDebug("Restoring PulseAudio card '%s' to profile '%s'",
+                m_voicecallcard.c_str(), m_voicecallhighest.c_str());
+        o = pa_context_set_card_profile_by_name(m_context,
+            m_voicecallcard.c_str(), m_voicecallhighest.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+            return;
+    }
+
+    /* Find highest compatible sink/source elements from the voicecall
+       compatible card (on touch this means the pulse droid element) */
+    m_nametoset = m_valuetoset = "";
+    o = pa_context_get_sink_info_list(m_context, sinkinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_sink_info_list"))
+        return;
+    if ((m_nametoset != "") && (m_nametoset != m_defaultsink)) {
+        qDebug("Setting PulseAudio default sink to '%s'", m_nametoset.c_str());
+        o = pa_context_set_default_sink(m_context, m_nametoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_sink"))
+            return;
+    }
+    if (m_valuetoset != "") {
+        qDebug("Setting PulseAudio sink '%s' port '%s'",
+                m_nametoset.c_str(), m_valuetoset.c_str());
+        o = pa_context_set_sink_port_by_name(m_context, m_nametoset.c_str(),
+                                             m_valuetoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_sink_port_by_name"))
+            return;
+    }
+
+    /* Same for source */
+    m_nametoset = m_valuetoset = "";
+    o = pa_context_get_source_info_list(m_context, sourceinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_source_info_list"))
+        return;
+    if ((m_nametoset != "") && (m_nametoset != m_defaultsource)) {
+        qDebug("Setting PulseAudio default source to '%s'", m_nametoset.c_str());
+        o = pa_context_set_default_source(m_context, m_nametoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_default_source"))
+            return;
+    }
+    if (m_valuetoset != "") {
+        qDebug("Setting PulseAudio source '%s' port '%s'",
+                m_nametoset.c_str(), m_valuetoset.c_str());
+        o = pa_context_set_source_port_by_name(m_context, m_nametoset.c_str(),
+                                               m_valuetoset.c_str(), success_cb, this);
+        if (!handleOperation(o, "pa_context_set_source_port_by_name"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+
+    /* Notify if the list of audio modes changed */
+    if (p_availableAudioModes != m_availableAudioModes)
+        Q_EMIT availableAudioModesChanged(m_availableAudioModes);
+
+    /* Notify if call mode changed */
+    if (p_audiomode != m_audiomode) {
+        Q_EMIT audioModeChanged(m_audiomode);
+    }
+
+    /* If no more active voicecall, restore previous saved pulseaudio state */
+    if (callstatus == CallEnded) {
+        restoreVoiceCall();
+    }
+
+    /* In case the app had set mute when the call wasn't active, make sure we reflect it here */
+    if (m_callstatus != CallEnded)
+        setMicMute(m_micmute);
+}
+
+void QPulseAudioEngineWorker::setMicMute(bool muted)
+{
+    if (!createPulseContext()) {
+       return;
+    }
+ 
+    m_micmute = muted;
+
+    if (m_callstatus == CallEnded)
+        return;
+
+    pa_threaded_mainloop_lock(m_mainLoop);
+
+    m_nametoset = "";
+    pa_operation *o = pa_context_get_source_info_list(m_context, sourceinfo_cb, this);
+    if (!handleOperation(o, "pa_context_get_source_info_list"))
+        return;
+
+    if (m_nametoset != "") {
+        int m = m_micmute ? 1 : 0;
+        qDebug("Setting PulseAudio source '%s' muted '%d'", m_nametoset.c_str(), m);
+        o = pa_context_set_source_mute_by_name(m_context, 
+            m_nametoset.c_str(), m, success_cb, this);
+        if (!handleOperation(o, "pa_context_set_source_mute_by_name"))
+            return;
+    }
+
+    pa_threaded_mainloop_unlock(m_mainLoop);
+}
+
+void QPulseAudioEngineWorker::plugCardCallback(const pa_card_info *info)
+{
+    qDebug("Notified about card (%s) add event from PulseAudio", info->name);
+
+    /* Check if it's indeed a BT device (with at least one hsp profile) */
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP))
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) && 
+                  info->profiles2[i]->available != 0) {
+            qDebug("Found a2dp");
+            a2dp = info->profiles2[i];
+        }
+        qDebug("%s", info->profiles2[i]->name);
+    }
+
+    if ((!info->active_profile || !strcmp(info->active_profile->name, "off")) && a2dp) {
+        qDebug("No profile set");
+        m_default_bt_card_fallback = info->name;
+    }
+
+    /* We only care about BT (HSP) devices, and if one is not already available */
+    if ((m_callstatus != CallEnded) && ((m_bt_hsp == "") || (m_bt_hsp_a2dp == ""))) {
+        if (hsp)
+            m_handleevent = true;
+    }
+}
+
+void QPulseAudioEngineWorker::updateCardCallback(const pa_card_info *info)
+{
+    qDebug("Notified about card (%s) changes event from PulseAudio", info->name);
+
+    /* Check if it's indeed a BT device (with at least one hsp profile) */
+    pa_card_profile_info2 *hsp = NULL, *a2dp = NULL;
+    for (int i = 0; i < info->n_profiles; i++) {
+        if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_HSP))
+            hsp = info->profiles2[i];
+        else if (!strcmp(info->profiles2[i]->name, PULSEAUDIO_PROFILE_A2DP) && 
+                  info->profiles2[i]->available != 0) {
+            qDebug("Found a2dp");
+            a2dp = info->profiles2[i];
+        }
+        qDebug("%s", info->profiles2[i]->name);
+    }
+
+    if ((!info->active_profile || !strcmp(info->active_profile->name, "off")) && a2dp) {
+        qDebug("No profile set");
+        m_default_bt_card_fallback = info->name;
+    }
+
+
+    /* We only care if the card event for the voicecall capable card */
+    if ((m_callstatus == CallActive) && (!strcmp(info->name, m_voicecallcard.c_str()))) {
+        if (m_audiomode == AudioModeWiredHeadset) {
+            /* If previous mode is wired, it means it got unplugged */
+            m_handleevent = true;
+            m_audiomodetoset = AudioModeBtOrWiredOrEarpiece;
+        } else if ((m_audiomode == AudioModeEarpiece) || ((m_audiomode == AudioModeSpeaker))) {
+            /* Now only trigger the event in case wired headset/headphone is now available */
+            pa_card_port_info *port_info = NULL;
+            for (int i = 0; i < info->n_ports; i++) {
+                if (info->ports[i] && (info->ports[i]->available == PA_PORT_AVAILABLE_YES) && (
+                            !strcmp(info->ports[i]->name, "output-wired_headset") ||
+                            !strcmp(info->ports[i]->name, "output-wired_headphone"))) {
+                    m_handleevent = true;
+                    m_audiomodetoset = AudioModeWiredOrEarpiece;
+                }
+            }
+        } else if (m_audiomode == AudioModeBluetooth) {
+            /* Handle the event so we can update the audiomodes */
+            m_handleevent = true;
+            m_audiomodetoset = AudioModeBluetooth;
+        }
+    }
+}
+
+void QPulseAudioEngineWorker::unplugCardCallback()
+{
+    if (m_callstatus != CallEnded) {
+        m_handleevent = true;
+    }
+}
+
+void QPulseAudioEngineWorker::handleCardEvent(const int evt, const unsigned int idx)
+{
+    pa_operation *o = NULL;
+
+    /* Internal state var used to know if we need to update our internal state */
+    m_handleevent = false;
+
+    if (evt == PA_SUBSCRIPTION_EVENT_NEW) {
+        o = pa_context_get_card_info_by_index(m_context, idx, plug_card_cb, this);
+        if (!handleOperation(o, "pa_context_get_card_info_by_index"))
+            return;
+
+        if (m_default_bt_card_fallback != "") {
+            o = pa_context_set_card_profile_by_name(m_context,
+                m_default_bt_card_fallback.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+            if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+                return;
+            m_default_bt_card_fallback = "";
+        }
+
+        if (m_handleevent) {
+            qDebug("Adding new BT-HSP capable device");
+            /* In case A2DP is available, switch to HSP */
+            if (setupVoiceCall() < 0)
+                return;
+            /* Enable the HSP output port  */
+            setCallMode(m_callstatus, AudioModeBluetooth);
+        }
+    } else if (evt == PA_SUBSCRIPTION_EVENT_CHANGE) {
+        o = pa_context_get_card_info_by_index(m_context, idx, update_card_cb, this);
+        if (!handleOperation(o, "pa_context_get_card_info_by_index"))
+            return;
+
+        if (m_default_bt_card_fallback != "") {
+            o = pa_context_set_card_profile_by_name(m_context,
+                m_default_bt_card_fallback.c_str(), PULSEAUDIO_PROFILE_A2DP, success_cb, this);
+            if (!handleOperation(o, "pa_context_set_card_profile_by_name"))
+                return;
+            m_default_bt_card_fallback = "";
+        }
+
+        if (m_handleevent) {
+            /* In this case it means the handset state changed */
+            qDebug("Notifying card changes for the voicecall capable card");
+            setCallMode(m_callstatus, m_audiomodetoset);
+        }
+    } else if (evt == PA_SUBSCRIPTION_EVENT_REMOVE) {
+        /* Check if the main HSP card was removed */
+        if (m_bt_hsp != "") {
+            o = pa_context_get_card_info_by_name(m_context, m_bt_hsp.c_str(), unplug_card_cb, this);
+            if (!handleOperation(o, "pa_context_get_sink_info_by_name"))
+                return;
+        }
+        if (m_bt_hsp_a2dp != "") {
+            o = pa_context_get_card_info_by_name(m_context, m_bt_hsp_a2dp.c_str(), unplug_card_cb, this);
+            if (!handleOperation(o, "pa_context_get_sink_info_by_name"))
+                return;
+        }
+        if (m_handleevent) {
+            qDebug("Notifying about BT-HSP card removal");
+            /* Needed in order to save the default sink/source */
+            if (setupVoiceCall() < 0)
+                return;
+            /* Enable the default handset output port  */
+            setCallMode(m_callstatus, AudioModeWiredOrEarpiece);
+        }
+    }
+}
+
+Q_GLOBAL_STATIC(QPulseAudioEngine, pulseEngine);
+
+QPulseAudioEngine::QPulseAudioEngine(QObject *parent) :
+    QObject(parent)
+{
+    qRegisterMetaType<CallStatus>();
+    qRegisterMetaType<AudioMode>();
+    qRegisterMetaType<AudioModes>();
+    mWorker = new QPulseAudioEngineWorker();
+    QObject::connect(mWorker, SIGNAL(audioModeChanged(const AudioMode)), this, SIGNAL(audioModeChanged(const AudioMode)), Qt::QueuedConnection);
+    QObject::connect(mWorker, SIGNAL(availableAudioModesChanged(const AudioModes)), this, SIGNAL(availableAudioModesChanged(const AudioModes)), Qt::QueuedConnection);
+    mWorker->createPulseContext();
+    mWorker->moveToThread(&mThread);
+    mThread.start();
+}
+
+QPulseAudioEngine::~QPulseAudioEngine()
+{
+    mThread.quit();
+    mThread.wait();
+}
+
+QPulseAudioEngine *QPulseAudioEngine::instance()
+{
+    QPulseAudioEngine *engine = pulseEngine();
+    return engine;
+}
+
+void QPulseAudioEngine::setCallMode(CallStatus callstatus, AudioMode audiomode)
+{
+    QMetaObject::invokeMethod(mWorker, "setCallMode", Qt::QueuedConnection, Q_ARG(CallStatus, callstatus), Q_ARG(AudioMode, audiomode));
+}
+
+void QPulseAudioEngine::setMicMute(bool muted)
+{
+    QMetaObject::invokeMethod(mWorker, "setMicMute", Qt::QueuedConnection, Q_ARG(bool, muted));
+}
+
+QT_END_NAMESPACE
+
 
=== added file 'handler/qpulseaudioengine.h'
--- handler/qpulseaudioengine.h	1970-01-01 00:00:00 +0000
+++ handler/qpulseaudioengine.h	2017-04-05 14:05:16 +0000
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file was taken from qt5 and modified by 
+** David Henningsson <[e-mail]> for usage in 
+** telepathy-ofono.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+****************************************************************************/
+
+#ifndef QPULSEAUDIOENGINE_H
+#define QPULSEAUDIOENGINE_H
+
+#include <QtCore/qmap.h>
+#include <QtCore/qbytearray.h>
+#include <QThread>
+#include <pulse/pulseaudio.h>
+
+enum AudioMode {
+    AudioModeEarpiece = 0x0001,
+    AudioModeWiredHeadset = 0x0002,
+    AudioModeSpeaker = 0x0004,
+    AudioModeBluetooth = 0x0008,
+    AudioModeBtOrWiredOrEarpiece = AudioModeBluetooth | AudioModeWiredHeadset | AudioModeEarpiece,
+    AudioModeWiredOrEarpiece = AudioModeWiredHeadset | AudioModeEarpiece,
+    AudioModeWiredOrSpeaker = AudioModeWiredHeadset | AudioModeSpeaker,
+    AudioModeBtOrWiredOrSpeaker = AudioModeBluetooth | AudioModeWiredOrSpeaker
+};
+
+Q_DECLARE_METATYPE(AudioMode)
+
+typedef QList<AudioMode> AudioModes;
+Q_DECLARE_METATYPE(AudioModes)
+
+enum CallStatus {
+    CallRinging,
+    CallActive,
+    CallEnded
+};
+
+Q_DECLARE_METATYPE(CallStatus)
+
+QT_BEGIN_NAMESPACE
+
+class QPulseAudioEngineWorker : public QObject
+{
+    Q_OBJECT
+
+public:
+    QPulseAudioEngineWorker(QObject *parent = 0);
+    ~QPulseAudioEngineWorker();
+
+    pa_threaded_mainloop *mainloop() { return m_mainLoop; }
+    pa_context *context() { return m_context; }
+    bool createPulseContext(void);
+    int setupVoiceCall(void);
+    void restoreVoiceCall(void);
+    /* Callbacks to be used internally */
+    void cardInfoCallback(const pa_card_info *card);
+    void sinkInfoCallback(const pa_sink_info *sink);
+    void sourceInfoCallback(const pa_source_info *source);
+    void serverInfoCallback(const pa_server_info *server);
+    void plugCardCallback(const pa_card_info *card);
+    void updateCardCallback(const pa_card_info *card);
+    void unplugCardCallback();
+
+Q_SIGNALS:
+    void audioModeChanged(const AudioMode mode);
+    void availableAudioModesChanged(const AudioModes modes);
+
+public Q_SLOTS:
+    void handleCardEvent(const int evt, const unsigned int idx);
+    void setCallMode(CallStatus callstatus, AudioMode audiomode);
+    void setMicMute(bool muted); /* True if muted, false if unmuted */
+
+private:
+    pa_mainloop_api *m_mainLoopApi;
+    pa_threaded_mainloop *m_mainLoop;
+    pa_context *m_context;
+
+    AudioModes m_availableAudioModes;
+    CallStatus m_callstatus;
+    AudioMode m_audiomode;
+    AudioMode m_audiomodetoset;
+    bool m_micmute, m_handleevent;
+    std::string m_nametoset, m_valuetoset;
+    std::string m_defaultsink, m_defaultsource;
+    std::string m_bt_hsp, m_bt_hsp_a2dp;
+    std::string m_default_bt_card_fallback;
+    std::string m_voicecallcard, m_voicecallhighest, m_voicecallprofile;
+
+    bool handleOperation(pa_operation *operation, const char *func_name);
+    void releasePulseContext(void);
+};
+
+class QPulseAudioEngine : public QObject
+{
+    Q_OBJECT
+public:
+    explicit QPulseAudioEngine(QObject *parent = 0);
+    ~QPulseAudioEngine();
+    static QPulseAudioEngine *instance();
+
+    void setCallMode(CallStatus callstatus, AudioMode audiomode);
+    void setMicMute(bool muted); /* True if muted, false if unmuted */
+
+Q_SIGNALS:
+    void audioModeChanged(const AudioMode mode);
+    void availableAudioModesChanged(const AudioModes modes);
+private:
+    QPulseAudioEngineWorker *mWorker;
+    QThread mThread;
+};
+
+QT_END_NAMESPACE
+
+#endif
 
=== modified file 'handler/texthandler.cpp'
--- handler/texthandler.cpp	2016-11-23 19:37:30 +0000
+++ handler/texthandler.cpp	2017-04-05 14:05:16 +0000
@@ -35,10 +35,39 @@
 
 TextHandler::TextHandler(QObject *parent)
 : QObject(parent)
+  , mMessagingAppMonitor("com.canonical.MessagingApp", QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForRegistration|QDBusServiceWatcher::WatchForUnregistration), mMessagingAppRegistered(false)
 {
     qDBusRegisterMetaType<AttachmentStruct>();
     qDBusRegisterMetaType<AttachmentList>();
     qRegisterMetaType<PendingMessage>();
+    connect(&mMessagingAppMonitor, SIGNAL(serviceRegistered(const QString&)), SLOT(onMessagingAppOpen()));
+    connect(&mMessagingAppMonitor, SIGNAL(serviceUnregistered(const QString&)), SLOT(onMessagingAppClosed()));
+    connect(TelepathyHelper::instance(), &TelepathyHelper::accountAdded, [=](AccountEntry *account) {
+        if (mMessagingAppRegistered && !account->active() && account->protocolInfo()->leaveRoomsOnClose()) {
+            account->reconnect();
+        }
+    });
+}
+
+void TextHandler::onMessagingAppOpen()
+{
+    mMessagingAppRegistered = true;
+    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->accounts()) {
+        if (!account->active() && account->protocolInfo()->leaveRoomsOnClose()) {
+            account->reconnect();
+        }
+    }
+}
+
+void TextHandler::onMessagingAppClosed()
+{
+    mMessagingAppRegistered = false;
+    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->accounts()) {
+        if (account->protocolInfo()->leaveRoomsOnClose()) {
+            account->requestDisconnect();
+        }
+    }
+
 }
 
 TextHandler *TextHandler::instance()
@@ -168,8 +197,14 @@
     if (chatType == Tp::HandleTypeNone && targetIds.size() == 1) {
         chatType = Tp::HandleTypeContact;
     }
+
     QString roomId = properties["threadId"].toString();
 
+    // try to use the threadId as participantId if empty
+    if (chatType == Tp::HandleTypeContact && targetIds.isEmpty()) {
+        targetIds << roomId;
+    }
+
     Q_FOREACH(const Tp::TextChannelPtr &channel, mChannels) {
         int count = 0;
         AccountEntry *channelAccount = TelepathyHelper::instance()->accountForConnection(channel->connection());
@@ -275,3 +310,15 @@
     return true;
 }
 
+void TextHandler::leaveRooms(const QString &accountId, const QString &message)
+{
+    Q_FOREACH(const Tp::TextChannelPtr &channel, mChannels) {
+        if (channel->targetHandleType() != Tp::HandleTypeRoom) {
+            continue;
+        }
+        AccountEntry *account = TelepathyHelper::instance()->accountForConnection(channel->connection());
+        if (account && account->accountId() == accountId) {
+            leaveChat(channel->objectPath(), message);
+        }
+    }
+}
 
=== modified file 'handler/texthandler.h'
--- handler/texthandler.h	2016-11-23 19:28:18 +0000
+++ handler/texthandler.h	2017-04-05 14:05:16 +0000
@@ -48,11 +48,15 @@
     void inviteParticipants(const QString &objectPath, const QStringList &participants, const QString &message);
     void removeParticipants(const QString &objectPath, const QStringList &participants, const QString &message);
     bool leaveChat(const QString &objectPath, const QString &message);
+    void leaveRooms(const QString &accountId, const QString &message);
 
 protected Q_SLOTS:
     void onTextChannelAvailable(Tp::TextChannelPtr channel);
     void onTextChannelInvalidated();
 
+    void onMessagingAppOpen();
+    void onMessagingAppClosed();
+
 protected:
     QList<Tp::TextChannelPtr> existingChannels(const QString &accountId, const QVariantMap &properties);
     Tp::TextChannelPtr existingChannelFromObjectPath(const QString &objectPath);
@@ -60,6 +64,8 @@
 private:
     explicit TextHandler(QObject *parent = 0);
     QList<Tp::TextChannelPtr> mChannels;
+    QDBusServiceWatcher mMessagingAppMonitor;
+    bool mMessagingAppRegistered;
 };
 
 #endif // TEXTHANDLER_H
 
=== modified file 'indicator/callchannelobserver.cpp'
--- indicator/callchannelobserver.cpp	2014-11-19 21:45:35 +0000
+++ indicator/callchannelobserver.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -21,6 +21,7 @@
 
 #include "callchannelobserver.h"
 #include "callnotification.h"
+#include "contactwatcher.h"
 #include "messagingmenu.h"
 #include "metrics.h"
 #include "telepathyhelper.h"
@@ -49,6 +50,13 @@
             SLOT(onHoldChanged()));
 
     mChannels.append(callChannel);
+    if (callChannel->isReady(Tp::CallChannel::FeatureCallState)) {
+        mCallStates[callChannel.data()] = callChannel->callState();
+    } else {
+        connect(callChannel->becomeReady(Tp::CallChannel::FeatureCallState), &Tp::PendingReady::finished, [&](){
+            mCallStates[callChannel.data()] = callChannel->callState();
+        });
+    }
 }
 
 void CallChannelObserver::onCallStateChanged(Tp::CallState state)
@@ -70,16 +78,23 @@
     switch (state) {
     case Tp::CallStateEnded:
         Q_EMIT callEnded(channel);
+
+        // if the missed flag is false, we still have to check if transitioning directly from Initialized to Ended
+        if (!missed && incoming) {
+            missed = mCallStates[channel.data()] == Tp::CallStateInitialised;
+        }
+
         // add the missed call to the messaging menu
         if (missed) {
             // FIXME: handle conf call
-            MessagingMenu::instance()->addCall(channel->targetContact()->id(), accountEntry->accountId(), QDateTime::currentDateTime());
+            MessagingMenu::instance()->addCall(ContactWatcher::normalizeIdentifier(channel->targetContact()->id()), accountEntry->accountId(), QDateTime::currentDateTime());
         } else {
             // and show a notification
             // FIXME: handle conf call
-            CallNotification::instance()->showNotificationForCall(QStringList() << channel->targetContact()->id(), CallNotification::CallEnded);
+            CallNotification::instance()->showNotificationForCall(QStringList() << ContactWatcher::normalizeIdentifier(channel->targetContact()->id()), CallNotification::CallEnded);
         }
 
+        mCallStates.remove(channel.data());
         mChannels.removeOne(channel);
 
         // update the metrics
@@ -93,6 +108,7 @@
         channel->setProperty("activeTimestamp", QDateTime::currentDateTime());
         break;
     }
+    mCallStates[channel.data()] = state;
 }
 
 void CallChannelObserver::onHoldChanged()
 
=== modified file 'indicator/callchannelobserver.h'
--- indicator/callchannelobserver.h	2014-01-20 12:57:43 +0000
+++ indicator/callchannelobserver.h	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -43,6 +43,7 @@
 
 private:
     QList<Tp::CallChannelPtr> mChannels;
+    QMap<Tp::CallChannel*,Tp::CallState> mCallStates;
 };
 
 #endif // CALLCHANNELOBSERVER_H
 
=== modified file 'indicator/displaynamesettings.cpp'
--- indicator/displaynamesettings.cpp	2016-03-18 19:02:50 +0000
+++ indicator/displaynamesettings.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016 Canonical, Ltd.
+ * Copyright (C) 2016-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -86,7 +86,7 @@
 
 void DisplayNameSettings::onAccountsChanged()
 {
-    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->accounts()) {
+    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->phoneAccounts()) {
         QString modemObjName = account->account()->parameters().value("modem-objpath").toString();
         if (mAccountNames.contains(modemObjName) && account->displayName() != mAccountNames[modemObjName]) {
             account->setDisplayName(mAccountNames[modemObjName]);
 
=== modified file 'indicator/messagingmenu.cpp'
--- indicator/messagingmenu.cpp	2016-11-23 19:28:18 +0000
+++ indicator/messagingmenu.cpp	2017-04-05 14:05:16 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2016 Canonical, Ltd.
+ * Copyright (C) 2012-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -244,6 +244,8 @@
             file = g_file_new_for_uri(avatar.toString().toUtf8().data());
             icon = g_file_icon_new(file);
         }
+
+        qDebug() << "notify message received:" << notificationData.encodedEventId.toUtf8();
         MessagingMenuMessage *message = messaging_menu_message_new(notificationData.encodedEventId.toUtf8().data(),
                                                                    icon,
                                                                    displayLabel.toUtf8().data(),
@@ -287,8 +289,9 @@
     mMessages.remove(messageId);
 }
 
-void MessagingMenu::addCallToMessagingMenu(Call call, const QString &text)
+void MessagingMenu::addCallToMessagingMenu(Call call, const QString &text, bool supportsTextReply)
 {
+    qDebug() << __PRETTY_FUNCTION__;
     GVariant *messages = NULL;
     GFile *file = g_file_new_for_uri(call.contactIcon.toString().toUtf8().data());
     GIcon *icon = g_file_icon_new(file);
@@ -300,7 +303,7 @@
                                                                call.timestamp.toMSecsSinceEpoch() * 1000);  // the value is expected to be in microseconds
 
     call.messageId = messaging_menu_message_get_id(message);
-    if (call.targetId != OFONO_PRIVATE_NUMBER && call.targetId != OFONO_UNKNOWN_NUMBER) {
+    if (supportsTextReply && call.targetId != OFONO_PRIVATE_NUMBER && call.targetId != OFONO_UNKNOWN_NUMBER) {
         messaging_menu_message_add_action(message,
                                           "callBack",
                                           C::gettext("Call back"), // label
@@ -334,6 +337,7 @@
 
 void MessagingMenu::addCall(const QString &targetId, const QString &accountId, const QDateTime &timestamp)
 {
+    qDebug() << __PRETTY_FUNCTION__;
     Call call;
     bool found = false;
     AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
@@ -392,7 +396,7 @@
     // so we just disable it
 #ifndef __aarch64__
     // place the messaging-menu item only after the contact fetch request is finished, as we can´t simply update
-    QObject::connect(request, &QContactAbstractRequest::stateChanged, [request, call, text, this]() {
+    QObject::connect(request, &QContactAbstractRequest::stateChanged, [=]() {
         // only process the results after the finished state is reached
         if (request->state() != QContactAbstractRequest::FinishedState) {
             return;
@@ -412,19 +416,13 @@
                 newCall.contactIcon = avatar;
             }
         }
-        addCallToMessagingMenu(newCall, text);
+        addCallToMessagingMenu(newCall, text, account->protocolInfo()->features() & Protocol::TextChats);
 #ifndef __aarch64__