CMakeLists.txt

+project(telepathy-ofono)
+cmake_minimum_required(VERSION 2.8)
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+set(TELEPATHY_OFONO telepathy-ofono)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+# Find includes in corresponding build directories
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+# Standard install paths
+include(GNUInstallDirs)
+
+# Check for include files
+include(CheckIncludeFileCXX)
+
+include(EnableCoverageReport)
+#####################################################################
+# Enable code coverage calculation with gcov/gcovr/lcov
+# Usage:
+#  * Switch build type to coverage (use ccmake or cmake-gui)
+#  * Invoke make, make test, make coverage
+#  * Find html report in subdir coveragereport
+#  * Find xml report feasible for jenkins in coverage.xml
+#####################################################################
+IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
+  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -coverage" )
+  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -coverage" )
+  ENABLE_COVERAGE_REPORT(TARGETS ${TELEPATHY_OFONO})
+ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
+
+find_package(LibPhoneNumber REQUIRED)
+find_package(Qt5Core)
+find_package(Qt5DBus)
+find_package(Qt5Network)
+add_definitions(-DQT_NO_KEYWORDS)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(TP_QT5 REQUIRED TelepathyQt5)
+pkg_check_modules(SQLITE3 REQUIRED sqlite3)
+pkg_check_modules(MC_PLUGINS REQUIRED mission-control-plugins)
+
+pkg_check_modules(PULSEAUDIO libpulse)
+if (PULSEAUDIO_FOUND)
+    add_definitions(-DUSE_PULSEAUDIO)
+    set(USE_PULSEAUDIO ON)
+    include_directories(${PULSEAUDIO_INCLUDE_DIRS})
+endif (PULSEAUDIO_FOUND)
+
+find_program(DBUS_RUNNER dbus-test-runner)
+
+if(NOT DAEMON_DIR)
+  set(DAEMON_DIR lib/telepathy)
+endif(NOT DAEMON_DIR)
+
+set(CMAKE_AUTOMOC ON)
+
+include_directories(${TP_QT5_INCLUDE_DIRS})
+include_directories(${Qt5Core_INCLUDE_DIRS})
+include_directories(${Qt5DBus_INCLUDE_DIRS})
+include_directories(${SQLITE3_INCLUDE_DIRS})
+include_directories(${LibPhoneNumber_INCLUDE_DIRS})
+include_directories(/usr/include/telepathy-qt5/)
+include_directories(/usr/include/ofono-qt/)
+
+find_library(TELEPATHY_QT5_LIBRARIES telepathy-qt5)
+find_library(TELEPATHY_QT5_SERVICE_LIBRARIES telepathy-qt5-service)
+find_library(OFONO_QT_LIBRARIES ofono-qt)
+
+qt5_add_resources(telepathyfono_RES sqlitetelepathyofono.qrc countrycodes.qrc)
+
+# update the .qrc file automatically when there are new schema files
+file(GLOB QRC_RESOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/schema/*.sql ${CMAKE_CURRENT_SOURCE_DIR}/schema/*.info)
+set(QRC_FILE ${CMAKE_CURRENT_SOURCE_DIR}/sqlitetelepathyofono.qrc)
+add_custom_command(
+    OUTPUT ${QRC_FILE}
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/update_qrc.sh ${QRC_FILE}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS ${QRC_RESOURCE_FILES}
+    )
+add_custom_target(qrc_update DEPENDS ${QRC_FILE} schema_update)
+
+set(TELEPATHY_OFONO_SRC 
+   main.cpp
+   protocol.cpp
+   connection.cpp
+   ofonotextchannel.cpp
+   ofonocallchannel.cpp
+   ofonoconferencecallchannel.cpp
+   emergencymodeiface.cpp
+   voicemailiface.cpp
+   audiooutputsiface.cpp
+   mmsdmanager.cpp
+   mmsdservice.cpp
+   mmsdmessage.cpp
+   mmsgroupcache.cpp
+   pendingmessagesmanager.cpp
+   phoneutils.cpp
+   powerdaudiomodemediator.cpp
+   powerddbus.cpp
+   sqlitedatabase.cpp
+   ussdiface.cpp
+   ${telepathyfono_RES})
+
+if(USE_PULSEAUDIO)
+    add_executable(${TELEPATHY_OFONO} qpulseaudioengine.cpp ${TELEPATHY_OFONO_SRC})
+else(USE_PULSEAUDIO)
+    add_executable(${TELEPATHY_OFONO} ${TELEPATHY_OFONO_SRC})
+endif(USE_PULSEAUDIO)
+qt5_use_modules(${TELEPATHY_OFONO} Core DBus Sql)
+add_dependencies(${TELEPATHY_OFONO} schema_update qrc_update)
+
+enable_testing()
+
+target_link_libraries(${TELEPATHY_OFONO} ${Qt5Core_LIBRARIES} ${Qt5DBus_LIBRARIES} ${WAUDIO_LIBRARIES} -ltelepathy-qt5 ${TELEPATHY_QT5_SERVICE_LIBRARIES}  ${Qt5Network_LIBRARIES} ${OFONO_QT_LIBRARIES} ${PULSEAUDIO_LIBRARIES} ${SQLITE3_LIBRARIES} ${LibPhoneNumber_LIBRARIES})
+install(TARGETS ${TELEPATHY_OFONO} DESTINATION ${DAEMON_DIR})
+
+configure_file(ofono.service.in org.freedesktop.Telepathy.ConnectionManager.ofono.service)
+install (FILES ofono.manager DESTINATION share/telepathy/managers)
+install (FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.ConnectionManager.ofono.service DESTINATION share/dbus-1/services)
+
+add_subdirectory(schema)
+add_subdirectory(tests)
+add_subdirectory(mc-plugin)

COPYING.LGPL

+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

audiooutputsiface.cpp

+/**
+ * Copyright (C) 2013 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: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
+ */
+
+#include <QDebug>
+
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/DBusObject>
+
+#include "audiooutputsiface.h"
+
+
+QDBusArgument &operator<<(QDBusArgument &argument, const AudioOutput &output)
+{
+    argument.beginStructure();
+    argument << output.id << output.type << output.name;
+    argument.endStructure();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, AudioOutput &output)
+{
+    argument.beginStructure();
+    argument >> output.id >> output.type >> output.name;
+    argument.endStructure();
+    return argument;
+}
+
+// Chan.I.AudioOutputs
+BaseChannelAudioOutputsInterface::Adaptee::Adaptee(BaseChannelAudioOutputsInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+    qDBusRegisterMetaType<AudioOutput>();
+    qDBusRegisterMetaType<AudioOutputList>();
+}
+
+struct TP_QT_NO_EXPORT BaseChannelAudioOutputsInterface::Private {
+    Private(BaseChannelAudioOutputsInterface *parent)
+        : adaptee(new BaseChannelAudioOutputsInterface::Adaptee(parent)) {
+    }
+    AudioOutputList audioOutputs;
+    QString activeAudioOutput;
+    SetActiveAudioOutputCallback setActiveAudioOutputCB;
+    BaseChannelAudioOutputsInterface::Adaptee *adaptee;
+};
+
+BaseChannelAudioOutputsInterface::Adaptee::~Adaptee()
+{
+}
+
+void BaseChannelAudioOutputsInterface::Adaptee::setActiveAudioOutput(const QString &id, const ChannelInterfaceAudioOutputsAdaptor::SetActiveAudioOutputContextPtr &context)
+{
+    if (!mInterface->mPriv->setActiveAudioOutputCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::DBusError error;
+    mInterface->mPriv->setActiveAudioOutputCB(id, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+BaseChannelAudioOutputsInterface::BaseChannelAudioOutputsInterface()
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_AUDIOOUTPUTS),
+      mPriv(new Private(this))
+{
+}
+
+BaseChannelAudioOutputsInterface::~BaseChannelAudioOutputsInterface()
+{
+    delete mPriv;
+}
+
+QString BaseChannelAudioOutputsInterface::activeAudioOutput() const
+{
+    return mPriv->activeAudioOutput;
+}
+
+AudioOutputList BaseChannelAudioOutputsInterface::audioOutputs() const
+{
+    return mPriv->audioOutputs;
+}
+
+void BaseChannelAudioOutputsInterface::setSetActiveAudioOutputCallback(const SetActiveAudioOutputCallback &cb)
+{
+    mPriv->setActiveAudioOutputCB = cb;
+}
+
+void BaseChannelAudioOutputsInterface::setActiveAudioOutput(const QString &id)
+{
+    mPriv->activeAudioOutput = id;
+    Q_EMIT mPriv->adaptee->activeAudioOutputChanged(id);
+}
+
+void BaseChannelAudioOutputsInterface::setAudioOutputs(const AudioOutputList &outputs)
+{
+    mPriv->audioOutputs = outputs;
+    Q_EMIT mPriv->adaptee->audioOutputsChanged(outputs);
+}
+
+QVariantMap BaseChannelAudioOutputsInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelAudioOutputsInterface::createAdaptor()
+{
+    (void) new ChannelInterfaceAudioOutputsAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+
+ChannelInterfaceAudioOutputsAdaptor::ChannelInterfaceAudioOutputsAdaptor(const QDBusConnection& bus, QObject* adaptee, QObject* parent)
+    : Tp::AbstractAdaptor(bus, adaptee, parent)
+{
+    connect(adaptee, SIGNAL(audioOutputsChanged(AudioOutputList)), SIGNAL(AudioOutputsChanged(AudioOutputList)));
+    connect(adaptee, SIGNAL(activeAudioOutputChanged(QString)), SIGNAL(ActiveAudioOutputChanged(QString)));
+}
+
+ChannelInterfaceAudioOutputsAdaptor::~ChannelInterfaceAudioOutputsAdaptor()
+{
+}
+
+void ChannelInterfaceAudioOutputsAdaptor::SetActiveAudioOutput(const QString &id, const QDBusMessage& dbusMessage)
+{
+    if (!adaptee()->metaObject()->indexOfMethod("setActiveAudioOutput(QString,ChannelInterfaceAudioOutputsAdaptor::SetActiveAudioOutputContextPtr)") == -1) {
+        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
+        return;
+    }
+
+    SetActiveAudioOutputContextPtr ctx = SetActiveAudioOutputContextPtr(
+            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
+    QMetaObject::invokeMethod(adaptee(), "setActiveAudioOutput",
+        Q_ARG(QString, id),
+        Q_ARG(ChannelInterfaceAudioOutputsAdaptor::SetActiveAudioOutputContextPtr, ctx));
+    return;
+}
+
+QString ChannelInterfaceAudioOutputsAdaptor::ActiveAudioOutput() const
+{
+    return qvariant_cast< QString >(adaptee()->property("activeAudioOutput"));
+}
+
+AudioOutputList ChannelInterfaceAudioOutputsAdaptor::AudioOutputs() const
+{
+    return qvariant_cast< AudioOutputList >(adaptee()->property("audioOutputs"));
+}
+

audiooutputsiface.h

+/**
+ * Copyright (C) 2013 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: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
+ */
+
+#ifndef OFONOAUDIOOUTPUTSIFACE_H
+#define OFONOAUDIOOUTPUTSIFACE_H
+
+// telepathy-qt
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/BaseChannel>
+#include <TelepathyQt/AbstractAdaptor>
+#include <TelepathyQt/DBusError>
+#include <TelepathyQt/Callbacks>
+
+#include "dbustypes.h"
+
+#define TP_QT_IFACE_CHANNEL_AUDIOOUTPUTS "com.canonical.Telephony.AudioOutputs"
+
+class BaseChannelAudioOutputsInterface;
+
+typedef Tp::SharedPtr<BaseChannelAudioOutputsInterface> BaseChannelAudioOutputsInterfacePtr;
+
+class TP_QT_EXPORT BaseChannelAudioOutputsInterface : public Tp::AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelAudioOutputsInterface)
+
+public:
+    static BaseChannelAudioOutputsInterfacePtr create() {
+        return BaseChannelAudioOutputsInterfacePtr(new BaseChannelAudioOutputsInterface());
+    }
+    template<typename BaseChannelAudioOutputsInterfaceSubclass>
+    static Tp::SharedPtr<BaseChannelAudioOutputsInterfaceSubclass> create() {
+        return Tp::SharedPtr<BaseChannelAudioOutputsInterfaceSubclass>(
+                   new BaseChannelAudioOutputsInterfaceSubclass());
+    }
+    QVariantMap immutableProperties() const;
+    virtual ~BaseChannelAudioOutputsInterface();
+    AudioOutputList audioOutputs() const;
+    QString activeAudioOutput() const;
+
+    typedef Tp::Callback2<void, QString, Tp::DBusError*> SetActiveAudioOutputCallback;
+    void setSetActiveAudioOutputCallback(const SetActiveAudioOutputCallback &cb);
+
+public Q_SLOTS:
+    void setActiveAudioOutput(const QString &id);
+    void setAudioOutputs(const AudioOutputList &outputs);
+
+protected:
+    BaseChannelAudioOutputsInterface();
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+
+class TP_QT_EXPORT ChannelInterfaceAudioOutputsAdaptor : public Tp::AbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", TP_QT_IFACE_CHANNEL_AUDIOOUTPUTS)
+    Q_CLASSINFO("D-Bus Introspection", ""
+"  <interface name=\"com.canonical.Telephony.AudioOutputs\">\n"
+"    <property access=\"read\" type=\"s\" name=\"ActiveAudioOutput\"/>\n"
+"    <property access=\"read\" type=\"a(sss)\" name=\"AudioOutputs\"/>\n"
+"    <method name=\"SetActiveAudioOutput\">\n"
+"      <arg direction=\"in\" type=\"s\" name=\"id\"/>\n"
+"    </method>\n"
+"    <signal name=\"AudioOutputsChanged\">\n"
+"      <arg type=\"a(sss)\" name=\"outputs\"/>\n"
+"    </signal>\n"
+"    <signal name=\"ActiveAudioOutputChanged\">\n"
+"      <arg type=\"s\" name=\"id\"/>\n"
+"    </signal>\n"
+"  </interface>\n"
+"")
+    Q_PROPERTY(AudioOutputList AudioOutputs READ AudioOutputs)
+    Q_PROPERTY(QString ActiveAudioOutput READ ActiveAudioOutput)
+public:
+    ChannelInterfaceAudioOutputsAdaptor(const QDBusConnection& dbusConnection, QObject* adaptee, QObject* parent);
+    virtual ~ChannelInterfaceAudioOutputsAdaptor();
+
+    typedef Tp::MethodInvocationContextPtr< > SetActiveAudioOutputContextPtr;
+
+public: // PROPERTIES
+    QString ActiveAudioOutput() const;
+    AudioOutputList AudioOutputs() const;
+
+public Q_SLOTS: // METHODS
+    void SetActiveAudioOutput(const QString &id, const QDBusMessage& dbusMessage);
+
+Q_SIGNALS: // SIGNALS
+    void AudioOutputsChanged(const AudioOutputList &outputs);
+    void ActiveAudioOutputChanged(const QString &id);
+};
+
+
+class TP_QT_NO_EXPORT BaseChannelAudioOutputsInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(AudioOutputList audioOutputs READ audioOutputs)
+    Q_PROPERTY(QString activeAudioOutput READ activeAudioOutput)
+
+public:
+    Adaptee(BaseChannelAudioOutputsInterface *interface);
+    ~Adaptee();
+    AudioOutputList audioOutputs() const
+    {
+        return mInterface->audioOutputs();
+    }
+
+    QString activeAudioOutput() const
+    {
+        return mInterface->activeAudioOutput();
+    }
+
+
+private Q_SLOTS:
+    void setActiveAudioOutput(const QString &id, const ChannelInterfaceAudioOutputsAdaptor::SetActiveAudioOutputContextPtr &context);
+
+Q_SIGNALS:
+    void activeAudioOutputChanged(const QString &id);
+    void audioOutputsChanged(const AudioOutputList &outputs);
+
+public:
+    BaseChannelAudioOutputsInterface *mInterface;
+};
+
+#endif

cmake/modules/EnableCoverageReport.cmake

+# - Creates a special coverage build type and target on GCC.
+#
+# Defines a function ENABLE_COVERAGE_REPORT which generates the coverage target
+# for selected targets. Optional arguments to this function are used to filter
+# unwanted results using globbing expressions. Moreover targets with tests for
+# the source code can be specified to trigger regenerating the report if the
+# test has changed
+#
+# ENABLE_COVERAGE_REPORT(TARGETS target... [FILTER filter...] [TESTS test targets...])
+#
+# To generate a coverage report first build the project with
+# CMAKE_BUILD_TYPE=coverage, then call make test and afterwards make coverage.
+#
+# The coverage report is based on gcov. Depending on the availability of lcov
+# a HTML report will be generated and/or an XML report of gcovr is found.
+# The generated coverage target executes all found solutions. Special targets
+# exist to create e.g. only the xml report: coverage-xml. 
+#
+# Copyright (C) 2010 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
+#
+# This program 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;
+# either version 2, or (at your option)
+# any later version.
+#
+# This program 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.
+#
+
+INCLUDE(ParseArguments)
+
+FIND_PACKAGE(Lcov)
+FIND_PACKAGE(gcovr)
+
+FUNCTION(ENABLE_COVERAGE_REPORT)
+    
+    # argument parsing
+    PARSE_ARGUMENTS(ARG "FILTER;TARGETS;TESTS" "" ${ARGN})
+    
+    SET(COVERAGE_RAW_FILE "${CMAKE_BINARY_DIR}/coverage.raw.info")
+    SET(COVERAGE_FILTERED_FILE "${CMAKE_BINARY_DIR}/coverage.info")
+    SET(COVERAGE_REPORT_DIR "${CMAKE_BINARY_DIR}/coveragereport")
+    SET(COVERAGE_XML_FILE "${CMAKE_BINARY_DIR}/coverage.xml")
+    SET(COVERAGE_XML_COMMAND_FILE "${CMAKE_BINARY_DIR}/coverage-xml.cmake")
+    
+    # decide if there is any tool to create coverage data
+    SET(TOOL_FOUND FALSE)
+    IF(LCOV_FOUND OR GCOVR_FOUND)
+        SET(TOOL_FOUND TRUE)
+    ENDIF()
+    IF(NOT TOOL_FOUND)
+        MESSAGE(STATUS "Cannot enable coverage targets because neither lcov nor gcovr are found.")
+    ENDIF()
+    
+    STRING(TOLOWER "${CMAKE_BUILD_TYPE}" COVERAGE_BUILD_TYPE)
+    IF(CMAKE_COMPILER_IS_GNUCXX AND TOOL_FOUND AND "${COVERAGE_BUILD_TYPE}" MATCHES "coverage")
+    
+        MESSAGE(STATUS "Coverage support enabled for targets: ${ARG_TARGETS}")
+    
+        # create coverage build type
+        SET(CMAKE_CXX_FLAGS_COVERAGE ${CMAKE_CXX_FLAGS_DEBUG} PARENT_SCOPE)
+        SET(CMAKE_C_FLAGS_COVERAGE ${CMAKE_C_FLAGS_DEBUG} PARENT_SCOPE)
+        SET(CMAKE_CONFIGURATION_TYPES ${CMAKE_CONFIGURATION_TYPES} coverage PARENT_SCOPE)
+    
+        # instrument targets
+        SET_TARGET_PROPERTIES(${ARG_TARGETS} PROPERTIES COMPILE_FLAGS --coverage
+                                                        LINK_FLAGS --coverage)
+    
+        # html report
+        IF (LCOV_FOUND)
+        
+            MESSAGE(STATUS "Enabling HTML coverage report")
+    
+            # set up coverage target
+            
+            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_RAW_FILE}
+                               COMMAND ${LCOV_EXECUTABLE} -c -d ${CMAKE_BINARY_DIR} -o ${COVERAGE_RAW_FILE}
+                               WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                               COMMENT "Collecting coverage data"
+                               DEPENDS ${ARG_TARGETS} ${ARG_TESTS}
+                               VERBATIM)
+            
+            # filter unwanted stuff
+            LIST(LENGTH ARG_FILTER FILTER_LENGTH)
+            IF(${FILTER_LENGTH} GREATER 0)
+                SET(FILTER COMMAND ${LCOV_EXECUTABLE})
+                FOREACH(F ${ARG_FILTER})
+                    SET(FILTER ${FILTER} -r ${COVERAGE_FILTERED_FILE} ${F})
+                ENDFOREACH()
+                SET(FILTER ${FILTER} -o ${COVERAGE_FILTERED_FILE})
+            ELSE()
+                SET(FILTER "")
+            ENDIF()
+            
+            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_FILTERED_FILE}
+                               COMMAND ${LCOV_EXECUTABLE} -e ${COVERAGE_RAW_FILE} "${CMAKE_SOURCE_DIR}*"  -o ${COVERAGE_FILTERED_FILE}
+                               ${FILTER}
+                               DEPENDS ${COVERAGE_RAW_FILE}
+                               COMMENT "Filtering recorded coverage data for project-relevant entries"
+                               VERBATIM)
+            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_REPORT_DIR}
+                               COMMAND ${CMAKE_COMMAND} -E make_directory ${COVERAGE_REPORT_DIR}
+                               COMMAND ${GENHTML_EXECUTABLE} --legend --show-details -t "${PROJECT_NAME} test coverage" -o ${COVERAGE_REPORT_DIR} ${COVERAGE_FILTERED_FILE}
+                               DEPENDS ${COVERAGE_FILTERED_FILE}
+                               COMMENT "Generating HTML coverage report in ${COVERAGE_REPORT_DIR}"
+                               VERBATIM)
+                               
+            ADD_CUSTOM_TARGET(coverage-html
+                              DEPENDS ${COVERAGE_REPORT_DIR})
+                              
+        ENDIF()
+        
+        # xml coverage report
+        IF(GCOVR_FOUND)
+        
+            MESSAGE(STATUS "Enabling XML coverage report")
+        
+            # gcovr cannot write directly to a file so the execution needs to
+            # be wrapped in a cmake file that generates the file output
+            FILE(WRITE ${COVERAGE_XML_COMMAND_FILE}
+                 "SET(ENV{LANG} en)\n")
+            FILE(APPEND ${COVERAGE_XML_COMMAND_FILE}
+                 "EXECUTE_PROCESS(COMMAND \"${GCOVR_EXECUTABLE}\" -x -r \"${CMAKE_SOURCE_DIR}\" OUTPUT_FILE \"${COVERAGE_XML_FILE}\" WORKING_DIRECTORY \"${CMAKE_BINARY_DIR}\")\n")
+        
+            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_XML_FILE}
+                               COMMAND ${CMAKE_COMMAND} ARGS -P ${COVERAGE_XML_COMMAND_FILE}
+                               COMMENT "Generating coverage XML report"
+                               VERBATIM)
+                               
+            ADD_CUSTOM_TARGET(coverage-xml
+                              DEPENDS ${COVERAGE_XML_FILE})
+        
+        ENDIF()
+        
+        # provide a global coverage target executing both steps if available
+        SET(GLOBAL_DEPENDS "")
+        IF(LCOV_FOUND)
+            LIST(APPEND GLOBAL_DEPENDS ${COVERAGE_REPORT_DIR})
+        ENDIF()
+        IF(GCOVR_FOUND)
+            LIST(APPEND GLOBAL_DEPENDS ${COVERAGE_XML_FILE})
+        ENDIF()
+        IF(LCOV_FOUND OR GCOVR_FOUND)
+            ADD_CUSTOM_TARGET(coverage
+                              DEPENDS ${GLOBAL_DEPENDS})
+        ENDIF()
+                          
+    ENDIF()
+
+ENDFUNCTION()   

cmake/modules/FindLcov.cmake

+# - Find lcov 
+# Will define:
+#
+# LCOV_EXECUTABLE - the lcov binary
+# GENHTML_EXECUTABLE - the genhtml executable
+#
+# Copyright (C) 2010 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
+#
+# This program 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;
+# either version 2, or (at your option)
+# any later version.
+#
+# This program 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.
+#
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PROGRAM(LCOV_EXECUTABLE lcov)
+FIND_PROGRAM(GENHTML_EXECUTABLE genhtml)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lcov DEFAULT_MSG LCOV_EXECUTABLE GENHTML_EXECUTABLE)
+
+# only visible in advanced view
+MARK_AS_ADVANCED(LCOV_EXECUTABLE GENHTML_EXECUTABLE)

cmake/modules/FindLibPhoneNumber.cmake

+set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
+
+include(GNUInstallDirs)
+include(LibFindMacros)
+
+# Include dir
+find_path(LibPhoneNumber_INCLUDE_DIR
+  NAMES phonenumberutil.h
+  PATHS "/usr/local/${CMAKE_INSTALL_INCLUDEDIR}" ${CMAKE_INSTALL_FULL_INCLUDEDIR}
+  PATH_SUFFIXES "phonenumbers"
+)
+
+# library itself
+find_library(LibPhoneNumber_LIBRARY
+  NAMES phonenumber
+  PATHS "/usr/local/${CMAKE_INSTALL_LIBDIR}" ${CMAKE_INSTALL_FULL_LIBDIR}
+)
+
+# Set the include dir variables and the libraries and let libfind_process do the rest.
+# NOTE: Singular variables for this library, plural for libraries this this lib depends on.
+set(LibPhoneNumber_PROCESS_INCLUDES LibPhoneNumber_INCLUDE_DIR)
+set(LibPhoneNumber_PROCESS_LIBS LibPhoneNumber_LIBRARY)
+libfind_process(LibPhoneNumber)

cmake/modules/Findgcovr.cmake

+# - Find gcovr scrip 
+# Will define:
+#
+# GCOVR_EXECUTABLE - the gcovr script
+#
+# Uses:
+#
+# GCOVR_ROOT - root to search for the script
+#
+# Copyright (C) 2011 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
+#
+# This program 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;
+# either version 2, or (at your option)
+# any later version.
+#
+# This program 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.
+#
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PROGRAM(GCOVR_EXECUTABLE gcovr HINTS ${GCOVR_ROOT} "${GCOVR_ROOT}/bin")
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(gcovr DEFAULT_MSG GCOVR_EXECUTABLE)
+
+# only visible in advanced view
+MARK_AS_ADVANCED(GCOVR_EXECUTABLE)

cmake/modules/LibFindMacros.cmake

+# Version 1.0 (2013-04-12)
+# Public Domain, originally written by Lasse Kärkkäinen <tronic@zi.fi>
+# Published at http://www.cmake.org/Wiki/CMake:How_To_Find_Libraries
+
+# If you improve the script, please modify the forementioned wiki page because
+# I no longer maintain my scripts (hosted as static files at zi.fi). Feel free
+# to remove this entire header if you use real version control instead.
+
+# Changelog:
+# 2013-04-12  Added version number (1.0) and this header, no other changes
+# 2009-10-08  Originally published
+
+
+# Works the same as find_package, but forwards the "REQUIRED" and "QUIET" arguments
+# used for the current package. For this to work, the first parameter must be the
+# prefix of the current package, then the prefix of the new package etc, which are
+# passed to find_package.
+macro (libfind_package PREFIX)
+  set (LIBFIND_PACKAGE_ARGS ${ARGN})
+  if (${PREFIX}_FIND_QUIETLY)
+    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)
+  endif (${PREFIX}_FIND_QUIETLY)
+  if (${PREFIX}_FIND_REQUIRED)
+    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)
+  endif (${PREFIX}_FIND_REQUIRED)
+  find_package(${LIBFIND_PACKAGE_ARGS})
+endmacro (libfind_package)
+
+# CMake developers made the UsePkgConfig system deprecated in the same release (2.6)
+# where they added pkg_check_modules. Consequently I need to support both in my scripts
+# to avoid those deprecated warnings. Here's a helper that does just that.
+# Works identically to pkg_check_modules, except that no checks are needed prior to use.
+macro (libfind_pkg_check_modules PREFIX PKGNAME)
+  if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    include(UsePkgConfig)
+    pkgconfig(${PKGNAME} ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARY_DIRS ${PREFIX}_LDFLAGS ${PREFIX}_CFLAGS)
+  else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    find_package(PkgConfig)
+    if (PKG_CONFIG_FOUND)
+      pkg_check_modules(${PREFIX} ${PKGNAME})
+    endif (PKG_CONFIG_FOUND)
+  endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+endmacro (libfind_pkg_check_modules)
+
+# Do the final processing once the paths have been detected.
+# If include dirs are needed, ${PREFIX}_PROCESS_INCLUDES should be set to contain
+# all the variables, each of which contain one include directory.
+# Ditto for ${PREFIX}_PROCESS_LIBS and library files.
+# Will set ${PREFIX}_FOUND, ${PREFIX}_INCLUDE_DIRS and ${PREFIX}_LIBRARIES.
+# Also handles errors in case library detection was required, etc.
+macro (libfind_process PREFIX)
+  # Skip processing if already processed during this run
+  if (NOT ${PREFIX}_FOUND)
+    # Start with the assumption that the library was found
+    set (${PREFIX}_FOUND TRUE)
+
+    # Process all includes and set _FOUND to false if any are missing
+    foreach (i ${${PREFIX}_PROCESS_INCLUDES})
+      if (${i})
+        set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})
+        mark_as_advanced(${i})
+      else (${i})
+        set (${PREFIX}_FOUND FALSE)
+      endif (${i})
+    endforeach (i)
+
+    # Process all libraries and set _FOUND to false if any are missing
+    foreach (i ${${PREFIX}_PROCESS_LIBS})
+      if (${i})
+        set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})
+        mark_as_advanced(${i})
+      else (${i})
+        set (${PREFIX}_FOUND FALSE)
+      endif (${i})
+    endforeach (i)
+
+    # Print message and/or exit on fatal error
+    if (${PREFIX}_FOUND)
+      if (NOT ${PREFIX}_FIND_QUIETLY)
+        message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
+      endif (NOT ${PREFIX}_FIND_QUIETLY)
+    else (${PREFIX}_FOUND)
+      if (${PREFIX}_FIND_REQUIRED)
+        foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})
+          message("${i}=${${i}}")
+        endforeach (i)
+        message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.")
+      endif (${PREFIX}_FIND_REQUIRED)
+    endif (${PREFIX}_FOUND)
+  endif (NOT ${PREFIX}_FOUND)
+endmacro (libfind_process)
+
+macro(libfind_library PREFIX basename)
+  set(TMP "")
+  if(MSVC80)
+    set(TMP -vc80)
+  endif(MSVC80)
+  if(MSVC90)
+    set(TMP -vc90)
+  endif(MSVC90)
+  set(${PREFIX}_LIBNAMES ${basename}${TMP})
+  if(${ARGC} GREATER 2)
+    set(${PREFIX}_LIBNAMES ${basename}${TMP}-${ARGV2})
+    string(REGEX REPLACE "\\." "_" TMP ${${PREFIX}_LIBNAMES})
+    set(${PREFIX}_LIBNAMES ${${PREFIX}_LIBNAMES} ${TMP})
+  endif(${ARGC} GREATER 2)
+  find_library(${PREFIX}_LIBRARY
+    NAMES ${${PREFIX}_LIBNAMES}
+    PATHS ${${PREFIX}_PKGCONF_LIBRARY_DIRS}
+  )
+endmacro(libfind_library)
+

cmake/modules/ParseArguments.cmake

+# Parse arguments passed to a function into several lists separated by
+# upper-case identifiers and options that do not have an associated list e.g.:
+#
+# SET(arguments
+#   hello OPTION3 world
+#   LIST3 foo bar
+#   OPTION2
+#   LIST1 fuz baz
+#   )
+# PARSE_ARGUMENTS(ARG "LIST1;LIST2;LIST3" "OPTION1;OPTION2;OPTION3" ${arguments})
+#
+# results in 7 distinct variables:
+#  * ARG_DEFAULT_ARGS: hello;world
+#  * ARG_LIST1: fuz;baz
+#  * ARG_LIST2:
+#  * ARG_LIST3: foo;bar
+#  * ARG_OPTION1: FALSE
+#  * ARG_OPTION2: TRUE
+#  * ARG_OPTION3: TRUE
+#
+# taken from http://www.cmake.org/Wiki/CMakeMacroParseArguments 
+
+MACRO(PARSE_ARGUMENTS prefix arg_names option_names)
+    SET(DEFAULT_ARGS)
+    FOREACH(arg_name ${arg_names})    
+        SET(${prefix}_${arg_name})
+    ENDFOREACH(arg_name)
+    FOREACH(option ${option_names})
+        SET(${prefix}_${option} FALSE)
+    ENDFOREACH(option)
+    
+    SET(current_arg_name DEFAULT_ARGS)
+    SET(current_arg_list)
+    FOREACH(arg ${ARGN})            
+        SET(larg_names ${arg_names})    
+        LIST(FIND larg_names "${arg}" is_arg_name)                   
+        IF (is_arg_name GREATER -1)
+            SET(${prefix}_${current_arg_name} ${current_arg_list})
+            SET(current_arg_name ${arg})
+            SET(current_arg_list)
+        ELSE (is_arg_name GREATER -1)
+            SET(loption_names ${option_names})    
+            LIST(FIND loption_names "${arg}" is_option)            
+            IF (is_option GREATER -1)
+                SET(${prefix}_${arg} TRUE)
+            ELSE (is_option GREATER -1)
+                SET(current_arg_list ${current_arg_list} ${arg})
+            ENDIF (is_option GREATER -1)
+        ENDIF (is_arg_name GREATER -1)
+    ENDFOREACH(arg)
+    SET(${prefix}_${current_arg_name} ${current_arg_list})
+ENDMACRO(PARSE_ARGUMENTS)

connection.h

+/**
+ * Copyright (C) 2013-2016 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: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
+ *          Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
+ */
+
+#ifndef OFONOCONNECTION_H
+#define OFONOCONNECTION_H
+
+// telepathy-qt
+#include <TelepathyQt/BaseConnection>
+#include <TelepathyQt/BaseChannel>
+#include <TelepathyQt/BaseCall>
+#include <TelepathyQt/AbstractAdaptor>
+#include <TelepathyQt/DBusError>
+
+// ofono-qt
+#include <ofonomodem.h>
+#include <ofonomodemmanager.h>
+#include <ofonomessagemanager.h>
+#include <ofonovoicecallmanager.h>
+#include <ofonovoicecall.h>
+#include <ofonocallvolume.h>
+#include <ofononetworkregistration.h>
+#include <ofonomessagewaiting.h>
+#include <ofonosupplementaryservices.h>
+#include <ofonosimmanager.h>
+
+// telepathy-ofono
+#include "ofonotextchannel.h"
+#include "ofonocallchannel.h"
+#include "emergencymodeiface.h"
+#include "voicemailiface.h"
+#include "mmsdmanager.h"
+#include "mmsdmessage.h"
+#include "dbustypes.h"
+#include "audiooutputsiface.h"
+#include "ussdiface.h"
+
+#ifdef USE_PULSEAUDIO
+#include "qpulseaudioengine.h"
+#endif
+
+class oFonoConnection;
+class oFonoTextChannel;
+class oFonoCallChannel;
+class oFonoConferenceCallChannel;
+class MMSDService;
+
+class oFonoConnection : public Tp::BaseConnection
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(oFonoConnection)
+public:
+    oFonoConnection(const QDBusConnection &dbusConnection,
+                    const QString &cmName,
+                    const QString &protocolName,
+                    const QVariantMap &parameters);
+
+    QStringList inspectHandles(uint handleType, const Tp::UIntList& handles, Tp::DBusError *error);
+    Tp::UIntList requestHandles(uint handleType, const QStringList& identifiers, Tp::DBusError* error);
+    Tp::BaseChannelPtr createChannel(const QVariantMap &request, Tp::DBusError *error);
+    Tp::ContactAttributesMap getContactAttributes(const Tp::UIntList &handles, const QStringList &ifaces, Tp::DBusError *error);
+    uint setPresence(const QString& status, const QString& statusMessage, Tp::DBusError *error);
+    void connect(Tp::DBusError *error);
+    void setSpeakerMode(bool active);
+    void setActiveAudioOutput(const QString &id);
+    AudioOutputList audioOutputs();
+    QString activeAudioOutput();
+    QStringList emergencyNumbers(Tp::DBusError *error);
+    bool voicemailIndicator(Tp::DBusError *error);
+    QString voicemailNumber(Tp::DBusError *error);
+    uint voicemailCount(Tp::DBusError *error);
+    void USSDInitiate(const QString &command, Tp::DBusError *error);
+    void USSDRespond(const QString &reply, Tp::DBusError *error);
+    void USSDCancel(Tp::DBusError *error);
+
+    Tp::BaseConnectionRequestsInterfacePtr requestsIface;
+    Tp::BaseConnectionSimplePresenceInterfacePtr simplePresenceIface;
+    Tp::BaseConnectionContactsInterfacePtr contactsIface;
+    BaseConnectionEmergencyModeInterfacePtr emergencyModeIface;
+    BaseConnectionVoicemailInterfacePtr voicemailIface;
+    BaseConnectionUSSDInterfacePtr supplementaryServicesIface;
+    uint newHandle(const QString &identifier);
+    uint newGroupHandle(const QString &identifier);
+
+    OfonoMessageManager *messageManager();
+    OfonoVoiceCallManager *voiceCallManager();
+    OfonoCallVolume *callVolume();
+    QMap<QString, oFonoCallChannel*> callChannels();
+
+    uint ensureHandle(const QString &phoneNumber);
+    uint ensureGroupHandle(const QString &groupId);
+    oFonoTextChannel* textChannelForId(const QString &id);
+    oFonoTextChannel* textChannelForMembers(const QStringList &members);
+    Tp::BaseChannelPtr createTextChannel(const QVariantMap &request, Tp::DBusError *error);
+    Tp::BaseChannelPtr createCallChannel(const QVariantMap &request, Tp::DBusError *error);
+
+    bool matchChannel(const Tp::BaseChannelPtr &channel, const QVariantMap &request, Tp::DBusError *error);
+    QString uniqueName() const;
+
+    QDBusObjectPath sendMMS(const QStringList &numbers, const OutgoingAttachmentList& attachments);
+
+
+    ~oFonoConnection();
+
+Q_SIGNALS:
+    void activeAudioOutputChanged(const QString &id);
+    void audioOutputsChanged(const AudioOutputList &outputs);
+    void channelMerged(const QDBusObjectPath &objPath);
+    void channelSplitted(const QDBusObjectPath &objPath);
+    void channelHangup(const QDBusObjectPath &objPath);
+    void lastChannelClosed();
+
+public Q_SLOTS:
+    void updateAudioRoute();
+    void updateAudioRouteToEarpiece();
+
+private Q_SLOTS:
+    void onOfonoIncomingMessage(const QString &message, const QVariantMap &info);
+    void onOfonoImmediateMessage(const QString &message, const QVariantMap &info);
+    void onOfonoCallAdded(const QString &call, const QVariantMap &properties);
+    void onTextChannelClosed();
+    void onCallChannelClosed();
+    void onCallChannelDestroyed();
+    void onValidityChanged(bool valid);
+    void onMMSDServiceAdded(const QString&);
+    void onMMSDServiceRemoved(const QString&);
+    void onMMSAdded(const QString &, const QVariantMap&);
+    void onMMSRemoved(const QString &);
+    void onCheckMMSServices();
+    void onMessageRead(const QString &id);
+    void onDeliveryReportReceived(const QString &messageId, const QVariantMap &info);
+    void onConferenceCallChannelClosed();
+    void onCallChannelMerged();
+    void onCallChannelSplitted();
+    void onMultipartyCallHeld();
+    void onMultipartyCallActive();
+    void updateOnlineStatus();
+    void onDisconnected();
+
+#ifdef USE_PULSEAUDIO
+    void onAudioModeChanged(AudioMode mode);
+    void onAvailableAudioModesChanged(AudioModes modes);
+#endif
+
+private:
+    void updateMcc();
+    bool isNetworkRegistered();
+    void addMMSToService(const QString &path, const QVariantMap &properties, const QString &servicePath);
+    void ensureTextChannel(const QString &message, const QVariantMap &info, bool flash);
+    QMap<uint, QString> mHandles;
+    uint mHandleCount;
+    QMap<uint, QString> mGroupHandles;
+    uint mGroupHandleCount;
+
+#ifdef USE_PULSEAUDIO
+    bool mHasPulseAudio;
+#endif
+
+    QList<oFonoTextChannel*> mTextChannels;
+    QMap<QString, oFonoCallChannel*> mCallChannels;
+
+    QStringList mModems;
+    OfonoModemManager *mOfonoModemManager;
+    OfonoMessageManager *mOfonoMessageManager;
+    OfonoVoiceCallManager *mOfonoVoiceCallManager;
+    OfonoCallVolume *mOfonoCallVolume;
+    OfonoNetworkRegistration *mOfonoNetworkRegistration;
+    OfonoMessageWaiting *mOfonoMessageWaiting;
+    OfonoSupplementaryServices *mOfonoSupplementaryServices;
+    OfonoSimManager *mOfonoSimManager;
+    OfonoModem *mOfonoModem;
+    Tp::SimplePresence mSelfPresence;
+    MMSDManager *mMmsdManager;
+    QMap<QString, MMSDService*> mMmsdServices;
+    QMap<QString, QList<MMSDMessage*> > mServiceMMSList;
+    oFonoConferenceCallChannel *mConferenceCall;
+    QString mModemPath;
+    QString mActiveAudioOutput;
+    AudioOutputList mAudioOutputs;
+};
+
+#endif

countrycodes.qrc

+<RCC>
+    <qresource prefix="/">
+        <file>countrycodes.txt</file>
+    </qresource>
+</RCC>

countrycodes.txt

+514:TP
+515:PH
+520:TH
+525:SG
+528:BN
+530:NZ
+537:PG
+539:TO
+540:SB
+541:VU
+542:FJ
+544:AS
+545:KI
+546:NC
+547:PF
+548:CK
+549:WS
+550:FM
+552:PW
+553:TV
+555:NU
+602:EG
+603:DZ
+604:MA
+605:TN
+606:LY
+607:GM
+608:SN
+609:MR
+610:ML
+611:GN
+612:CI
+613:BF
+614:NE
+615:TG
+616:BJ
+617:MU
+618:LR
+619:SL
+620:GH
+621:NG
+622:TD
+623:CF
+624:CM
+625:CV
+626:ST
+627:GQ
+628:GA
+629:CG
+630:CD
+631:AO
+632:GW
+633:SC
+634:SD
+635:RW
+636:ET
+637:SO
+638:DJ
+639:KE
+640:TZ
+641:UG
+642:BI
+643:MZ
+645:ZM
+646:MG
+647:RE
+648:ZW
+649:NA
+650:MW
+651:LS
+652:BW
+653:SZ
+654:KM
+655:ZA
+657:ER
+659:SS
+714:PA
+702:BZ
+704:GT
+706:SV
+708:HN
+710:NI
+712:CR
+716:PE
+202:GR
+204:NL
+206:BE
+208:FR
+722:AR
+724:BR
+213:AD
+214:ES
+216:HU
+730:CL
+219:HR
+732:CO
+222:IT
+736:BO
+738:GY
+740:EC
+230:CZ
+231:SK
+232:AT
+746:SR
+235:GB
+748:UY
+750:FK
+240:SE
+242:NO
+244:FI
+246:LT
+247:LV
+248:EE
+212:MC
+250:RU
+255:UA
+257:BY
+259:MD
+260:PL
+262:DE
+266:GI
+268:PT
+270:LU
+272:IE
+274:IS
+276:AL
+278:MT
+280:CY
+282:GE
+283:AM
+284:BG
+218:BA
+286:TR
+288:FO
+289:GE
+290:GL
+292:SM
+293:SI
+294:MK
+295:LI
+297:ME
+302:CA
+308:PM
+734:VE
+310:US
+311:US
+312:US
+316:US
+330:PR
+226:RO
+334:MX
+338:JM
+340:MQ
+342:BB
+344:AG
+228:CH
+346:KY
+348:VG
+350:BM
+352:GD
+354:MS
+356:KN
+358:LC
+360:VC
+362:AN
+363:AW
+364:BS
+365:AI
+366:DM
+368:CU
+744:PY
+370:DO
+372:HT
+374:TT
+376:VI
+234:GB
+405:IN
+400:AZ
+401:KZ
+402:BT
+404:IN
+238:DK
+410:PK
+412:AF
+413:LK
+414:MM
+415:LB
+416:JO
+417:SY
+418:IQ
+419:KW
+420:SA
+421:YE
+422:OM
+424:AE
+425:PS
+426:BH
+427:QA
+428:MN
+429:NP
+430:AE
+431:AE
+432:IR
+434:UZ
+436:TK
+437:KG
+438:TM
+440:JP
+441:JP
+450:KR
+452:VN
+454:HK
+455:MO
+456:KH
+457:LA
+460:CN
+466:TW
+467:KP
+220:RS
+470:BD
+472:MV
+502:MY
+505:AU
+510:ID

dbustypes.h

+/**
+ * Copyright (C) 2013 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: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
+ */
+
+#ifndef DBUSTYPES
+#define DBUSTYPES
+#include <QDBusObjectPath>
+
+struct AudioOutput {
+    QString id;
+    QString type;
+    QString name;
+};
+
+struct MessageStruct {
+    QDBusObjectPath path;
+    QVariantMap properties;
+};
+
+struct IncomingAttachmentStruct {
+    QString id;
+    QString contentType;
+    QString filePath;
+    quint64 offset;
+    quint64 length;
+};
+
+struct OutgoingAttachmentStruct {
+    QString id;
+    QString contentType;
+    QString filePath;
+};
+
+Q_DECLARE_METATYPE(AudioOutput)
+
+typedef QList<AudioOutput> AudioOutputList;
+Q_DECLARE_METATYPE(AudioOutputList)
+
+typedef QList<IncomingAttachmentStruct> IncomingAttachmentList;
+typedef QList<OutgoingAttachmentStruct> OutgoingAttachmentList;
+Q_DECLARE_METATYPE(IncomingAttachmentStruct)
+Q_DECLARE_METATYPE(OutgoingAttachmentStruct)
+Q_DECLARE_METATYPE(IncomingAttachmentList)
+Q_DECLARE_METATYPE(OutgoingAttachmentList)
+
+typedef QList<MessageStruct> MessageList;
+Q_DECLARE_METATYPE(MessageStruct)
+Q_DECLARE_METATYPE(MessageList)
+
+
+#endif

debian/changelog

-telepathy-ofono (0.2.20161109-1) UNRELEASED; urgency=medium
+telepathy-ofono (0.2.20161109-1~12.gbp7063d5) UNRELEASED; urgency=medium
 
+  ** SNAPSHOT build @7063d5a7e77f114db0606a3619e7e36d6c814157 **
+
+  [ Jonah Brüchert ]
   * Standards-version 4.1.3
   * compat 11
   * Change dependency on libhybris-utils to suggestion
 
- -- Jonah Brüchert <jbb@kaidan.im>  Wed, 04 Apr 2018 18:03:05 +0200
+  [ JBBgameich ]
+  * Update copyright
+  * Update git repository url
+  * Run wrap-and-sort
+
+