Merge lp:~tiagosh/telepathy-ofono/ussd into lp:telepathy-ofono

[Tiago Salem Herrmann]

Add initial USSD support

Add initial USSD support

--------------
Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~tiagosh/telephony-service/ussd/+merge/213935
https://code.launchpad.net/~tiagosh/dialer-app/ussd/+merge/213934

Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes)
Yes

Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?
Yes

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/telepathy-ofono) on device or emulator?
Yes

If you changed the UI, was the change specified/approved by design?
N/A

If you changed the packaging (debian), did you subscribe a core-dev to this MP?
N/A

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:74
http://jenkins.qa.ubuntu.com/job/telepathy-ofono-ci/82/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-trusty-amd64-ci/61
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-trusty-armhf-ci/61
        deb: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-trusty-armhf-ci/61/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-trusty-i386-ci/60

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telepathy-ofono-ci/82/rebuild

review: Approve (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
Yes

Did CI run pass? If not, please explain why.
Yes

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
Yes

Code looks good and works as expected!

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-07 20:03:39 +0000
+++ CMakeLists.txt	2014-04-02 22:00:18 +0000
@@ -97,6 +97,7 @@
    pendingmessagesmanager.cpp
    phoneutils.cpp
    sqlitedatabase.cpp
+   ussdiface.cpp
    ${telepathyfono_RES})
 
 if(USE_PULSEAUDIO)

=== modified file 'connection.cpp'
--- connection.cpp	2014-03-19 02:36:35 +0000
+++ connection.cpp	2014-04-02 22:00:18 +0000
@@ -153,6 +153,7 @@
     mOfonoCallVolume = new OfonoCallVolume(setting, modemPath);
     mOfonoNetworkRegistration = new OfonoNetworkRegistration(setting, modemPath);
     mOfonoMessageWaiting = new OfonoMessageWaiting(setting, modemPath);
+    mOfonoSupplementaryServices = new OfonoSupplementaryServices(setting, modemPath);
 
     setSelfHandle(newHandle("<SelfHandle>"));
 
@@ -203,6 +204,14 @@
     voicemailIface->setVoicemailNumberCallback(Tp::memFun(this,&oFonoConnection::voicemailNumber));
     plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(voicemailIface));
 
+    supplementaryServicesIface = BaseConnectionUSSDInterface::create();
+    supplementaryServicesIface->setInitiateCallback(Tp::memFun(this,&oFonoConnection::USSDInitiate));
+    supplementaryServicesIface->setRespondCallback(Tp::memFun(this,&oFonoConnection::USSDRespond));
+    supplementaryServicesIface->setCancelCallback(Tp::memFun(this,&oFonoConnection::USSDCancel));
+    supplementaryServicesIface->StateChanged(mOfonoSupplementaryServices->state());
+    supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
+    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(supplementaryServicesIface));
+
     // Set Presence
     Tp::SimpleStatusSpec presenceOnline;
     presenceOnline.type = Tp::ConnectionPresenceTypeAvailable;
@@ -226,6 +235,7 @@
     if (mOfonoVoiceCallManager->modem()) {
         validModem = mOfonoVoiceCallManager->modem()->isValid();
         if (validModem) {
+            supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
             QObject::connect(mOfonoVoiceCallManager->modem(), SIGNAL(onlineChanged(bool)), SLOT(onValidityChanged(bool)));
         }
     }
@@ -246,7 +256,7 @@
     QObject::connect(mOfonoNetworkRegistration, SIGNAL(statusChanged(QString)), SLOT(onOfonoNetworkRegistrationChanged(QString)));
     QObject::connect(mOfonoMessageWaiting, SIGNAL(voicemailMessageCountChanged(int)), voicemailIface.data(), SLOT(setVoicemailCount(int)));
     QObject::connect(mOfonoMessageWaiting, SIGNAL(voicemailWaitingChanged(bool)), voicemailIface.data(), SLOT(setVoicemailIndicator(bool)));
-
+    
     QObject::connect(mRegisterTimer, SIGNAL(timeout()), SLOT(onTryRegister()));
 
     QObject::connect(mMmsdManager, SIGNAL(serviceAdded(const QString&)), SLOT(onMMSDServiceAdded(const QString&)));
@@ -256,6 +266,38 @@
     QObject::connect(mOfonoVoiceCallManager, SIGNAL(callAdded(QString,QVariantMap)), SLOT(updateAudioRoute()));
     QObject::connect(mOfonoVoiceCallManager, SIGNAL(callRemoved(QString)), SLOT(updateAudioRoute()));
 
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(notificationReceived(const QString &)), supplementaryServicesIface.data(), SLOT(NotificationReceived(const QString &)));
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(requestReceived(const QString &)), supplementaryServicesIface.data(), SLOT(RequestReceived(const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(initiateUSSDComplete(const QString &)), supplementaryServicesIface.data(), SLOT(InitiateUSSDComplete(const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(barringComplete(const QString &, const QString &, const QVariantMap &)), 
+        supplementaryServicesIface.data(), SLOT(BarringComplete(const QString &, const QString &, const QVariantMap &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(forwardingComplete(const QString &, const QString &, const QVariantMap &)), 
+        supplementaryServicesIface.data(), SLOT(ForwardingComplete(const QString &, const QString &, const QVariantMap &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(waitingComplete(const QString &, const QVariantMap &)), 
+        supplementaryServicesIface.data(), SLOT(WaitingComplete(const QString &, const QVariantMap &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(callingLinePresentationComplete(const QString &, const QString &)), 
+        supplementaryServicesIface.data(), SLOT(CallingLinePresentationComplete(const QString &, const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(connectedLinePresentationComplete(const QString &, const QString &)), 
+        supplementaryServicesIface.data(), SLOT(ConnectedLinePresentationComplete(const QString &, const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(callingLineRestrictionComplete(const QString &, const QString &)), 
+        supplementaryServicesIface.data(), SLOT(CallingLineRestrictionComplete(const QString &, const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(connectedLineRestrictionComplete(const QString &, const QString &)), 
+        supplementaryServicesIface.data(), SLOT(ConnectedLineRestrictionComplete(const QString &, const QString &)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(initiateFailed()), supplementaryServicesIface.data(), SLOT(InitiateFailed()));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(stateChanged(const QString&)), supplementaryServicesIface.data(), SLOT(StateChanged(const QString&)));
+
+    QObject::connect(mOfonoSupplementaryServices, SIGNAL(respondComplete(bool, const QString &)), supplementaryServicesIface.data(), SLOT(RespondComplete(bool, const QString &)));
+
     // workaround: we can't add services here as tp-ofono interfaces are not exposed on dbus
     // todo: use QDBusServiceWatcher
     QTimer::singleShot(1000, this, SLOT(onCheckMMSServices()));
@@ -493,6 +535,7 @@
     qDebug() << "validityChanged" << valid << "is network registered: " << isNetworkRegistered() << mRequestedSelfPresence.type;
     QObject::disconnect(mOfonoVoiceCallManager->modem(), 0,0,0);
     QObject::connect(mOfonoVoiceCallManager->modem(), SIGNAL(onlineChanged(bool)), SLOT(onValidityChanged(bool)));
+    supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
     if (!isNetworkRegistered() && mRequestedSelfPresence.type == Tp::ConnectionPresenceTypeAvailable) {
         setOnline(false);
         onTryRegister();
@@ -933,6 +976,21 @@
     }
 }
 
+void oFonoConnection::USSDInitiate(const QString &command, Tp::DBusError *error)
+{
+    mOfonoSupplementaryServices->initiate(command);
+}
+
+void oFonoConnection::USSDRespond(const QString &reply, Tp::DBusError *error)
+{
+    mOfonoSupplementaryServices->respond(reply);
+}
+
+void oFonoConnection::USSDCancel(Tp::DBusError *error)
+{
+    mOfonoSupplementaryServices->cancel();
+}
+
 void oFonoConnection::updateAudioRoute()
 {
     QByteArray pulseAudioDisabled = qgetenv("PA_DISABLED");

=== modified file 'connection.h'
--- connection.h	2014-02-14 17:48:08 +0000
+++ connection.h	2014-04-02 22:00:18 +0000
@@ -37,6 +37,7 @@
 #include <ofonocallvolume.h>
 #include <ofononetworkregistration.h>
 #include <ofonomessagewaiting.h>
+#include <ofonosupplementaryservices.h>
 
 // telepathy-ofono
 #include "ofonotextchannel.h"
@@ -46,6 +47,7 @@
 #include "mmsdmessage.h"
 #include "dbustypes.h"
 #include "speakeriface.h"
+#include "ussdiface.h"
 
 class oFonoConnection;
 class oFonoTextChannel;
@@ -76,11 +78,15 @@
     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;
     BaseConnectionVoicemailInterfacePtr voicemailIface;
+    BaseConnectionUSSDInterfacePtr supplementaryServicesIface;
     uint newHandle(const QString &identifier);
 
     OfonoMessageManager *messageManager();
@@ -144,6 +150,7 @@
     OfonoCallVolume *mOfonoCallVolume;
     OfonoNetworkRegistration *mOfonoNetworkRegistration;
     OfonoMessageWaiting *mOfonoMessageWaiting;
+    OfonoSupplementaryServices *mOfonoSupplementaryServices;
     uint mHandleCount;
     Tp::SimplePresence mSelfPresence;
     Tp::SimplePresence mRequestedSelfPresence;

=== modified file 'tests/dbus-test-wrapper.sh.in'
--- tests/dbus-test-wrapper.sh.in	2014-02-19 16:08:33 +0000
+++ tests/dbus-test-wrapper.sh.in	2014-04-02 22:00:18 +0000
@@ -11,6 +11,7 @@
 # we need to set this otherwise mission-control doesn't work properly
 dconf write /org/gnome/empathy/use-conn false
 
+export PA_DISABLED=1
 # start telepathy-ofono with the ofono-qt mock library
 LD_PRELOAD=@CMAKE_CURRENT_BINARY_DIR@/mock/libofono-qt.so ${CMAKE_BINARY_DIR}/telepathy-ofono &
 

=== added file 'ussdiface.cpp'
--- ussdiface.cpp	1970-01-01 00:00:00 +0000
+++ ussdiface.cpp	2014-04-02 22:00:18 +0000
@@ -0,0 +1,311 @@
+/**
+ * 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 <[e-mail]>
+ */
+
+#include <QDebug>
+
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/DBusObject>
+
+#include "ussdiface.h"
+
+// Conn.I.USSD
+BaseConnectionUSSDInterface::Adaptee::Adaptee(BaseConnectionUSSDInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+
+struct TP_QT_NO_EXPORT BaseConnectionUSSDInterface::Private {
+    Private(BaseConnectionUSSDInterface *parent)
+        : adaptee(new BaseConnectionUSSDInterface::Adaptee(parent)) {
+    }
+    QString state;
+    QString serial;
+    InitiateCallback initiateCB;
+    RespondCallback respondCB;
+    CancelCallback cancelCB;
+    BaseConnectionUSSDInterface::Adaptee *adaptee;
+};
+
+BaseConnectionUSSDInterface::Adaptee::~Adaptee()
+{
+}
+
+void BaseConnectionUSSDInterface::Adaptee::initiate(const QString &command, const ConnectionInterfaceUSSDAdaptor::InitiateContextPtr &context)
+{
+    if (!mInterface->mPriv->initiateCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::DBusError error;
+    mInterface->mPriv->initiateCB(command, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseConnectionUSSDInterface::Adaptee::respond(const QString &reply, const ConnectionInterfaceUSSDAdaptor::RespondContextPtr &context)
+{
+    if (!mInterface->mPriv->respondCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::DBusError error;
+    mInterface->mPriv->respondCB(reply, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseConnectionUSSDInterface::Adaptee::cancel(const ConnectionInterfaceUSSDAdaptor::CancelContextPtr &context)
+{
+    if (!mInterface->mPriv->cancelCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::DBusError error;
+    mInterface->mPriv->cancelCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+BaseConnectionUSSDInterface::BaseConnectionUSSDInterface()
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_USSD),
+      mPriv(new Private(this))
+{
+}
+
+BaseConnectionUSSDInterface::~BaseConnectionUSSDInterface()
+{
+    delete mPriv;
+}
+
+void BaseConnectionUSSDInterface::setInitiateCallback(const InitiateCallback &cb)
+{
+    mPriv->initiateCB = cb;
+}
+
+void BaseConnectionUSSDInterface::setRespondCallback(const RespondCallback &cb)
+{
+    mPriv->respondCB = cb;
+}
+
+void BaseConnectionUSSDInterface::setCancelCallback(const CancelCallback &cb)
+{
+    mPriv->cancelCB = cb;
+}
+
+QString BaseConnectionUSSDInterface::state() const
+{
+    return mPriv->state;
+}
+
+void BaseConnectionUSSDInterface::setSerial(const QString &serial) const
+{
+    mPriv->serial = serial;
+}
+
+
+QString BaseConnectionUSSDInterface::serial() const
+{
+    return mPriv->serial;
+}
+
+void BaseConnectionUSSDInterface::StateChanged(const QString &state)
+{
+    mPriv->state = state;
+    Q_EMIT mPriv->adaptee->stateChanged(state);
+}
+
+void BaseConnectionUSSDInterface::InitiateUSSDComplete(const QString &ussdResp)
+{
+    Q_EMIT mPriv->adaptee->initiateUSSDComplete(ussdResp);
+}
+
+void BaseConnectionUSSDInterface::RespondComplete(bool success, const QString &ussdResp)
+{
+    Q_EMIT mPriv->adaptee->respondComplete(success, ussdResp);
+}
+
+void BaseConnectionUSSDInterface::BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap)
+{
+    Q_EMIT mPriv->adaptee->barringComplete(ssOp, cbService, cbMap);
+}
+
+void BaseConnectionUSSDInterface::ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap)
+{
+    Q_EMIT mPriv->adaptee->forwardingComplete(ssOp, cfService, cfMap);
+}
+
+void BaseConnectionUSSDInterface::WaitingComplete(const QString &ssOp, const QVariantMap &cwMap)
+{
+    Q_EMIT mPriv->adaptee->waitingComplete(ssOp, cwMap);
+}
+
+void BaseConnectionUSSDInterface::CallingLinePresentationComplete(const QString &ssOp, const QString &status)
+{
+    Q_EMIT mPriv->adaptee->callingLinePresentationComplete(ssOp, status);
+}
+
+void BaseConnectionUSSDInterface::ConnectedLinePresentationComplete(const QString &ssOp, const QString &status)
+{
+    Q_EMIT mPriv->adaptee->connectedLinePresentationComplete(ssOp, status);
+}
+
+void BaseConnectionUSSDInterface::CallingLineRestrictionComplete(const QString &ssOp, const QString &status)
+{
+    Q_EMIT mPriv->adaptee->callingLineRestrictionComplete(ssOp, status);
+}
+
+void BaseConnectionUSSDInterface::ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status)
+{
+    Q_EMIT mPriv->adaptee->connectedLineRestrictionComplete(ssOp, status);
+}
+
+void BaseConnectionUSSDInterface::InitiateFailed()
+{
+    Q_EMIT mPriv->adaptee->initiateFailed();
+}
+
+void BaseConnectionUSSDInterface::NotificationReceived(const QString &message)
+{
+    Q_EMIT mPriv->adaptee->notificationReceived(message);
+}
+
+void BaseConnectionUSSDInterface::RequestReceived(const QString &message)
+{
+    Q_EMIT mPriv->adaptee->requestReceived(message);
+}
+
+
+QVariantMap BaseConnectionUSSDInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseConnectionUSSDInterface::createAdaptor()
+{
+    (void) new ConnectionInterfaceUSSDAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+
+ConnectionInterfaceUSSDAdaptor::ConnectionInterfaceUSSDAdaptor(const QDBusConnection& bus, QObject* adaptee, QObject* parent)
+    : Tp::AbstractAdaptor(bus, adaptee, parent)
+{
+    connect(adaptee, SIGNAL(notificationReceived(const QString &)), SIGNAL(NotificationReceived(const QString &)));
+    connect(adaptee, SIGNAL(requestReceived(const QString &)), SIGNAL(RequestReceived(const QString &)));
+
+    connect(adaptee, SIGNAL(initiateUSSDComplete(const QString &)), SIGNAL(InitiateUSSDComplete(const QString &)));
+
+    connect(adaptee, SIGNAL(barringComplete(const QString &, const QString &, const QVariantMap &)), 
+        SIGNAL(BarringComplete(const QString &, const QString &, const QVariantMap &)));
+
+    connect(adaptee, SIGNAL(forwardingComplete(const QString &, const QString &, const QVariantMap &)), 
+        SIGNAL(ForwardingComplete(const QString &, const QString &, const QVariantMap &)));
+
+    connect(adaptee, SIGNAL(waitingComplete(const QString &, const QVariantMap &)), 
+        SIGNAL(WaitingComplete(const QString &, const QVariantMap &)));
+
+    connect(adaptee, SIGNAL(callingLinePresentationComplete(const QString &, const QString &)), 
+        SIGNAL(CallingLinePresentationComplete(const QString &, const QString &)));
+
+    connect(adaptee, SIGNAL(connectedLinePresentationComplete(const QString &, const QString &)), 
+        SIGNAL(ConnectedLinePresentationComplete(const QString &, const QString &)));
+
+    connect(adaptee, SIGNAL(callingLineRestrictionComplete(const QString &, const QString &)), 
+        SIGNAL(CallingLineRestrictionComplete(const QString &, const QString &)));
+
+    connect(adaptee, SIGNAL(connectedLineRestrictionComplete(const QString &, const QString &)), 
+        SIGNAL(ConnectedLineRestrictionComplete(const QString &, const QString &)));
+
+    connect(adaptee, SIGNAL(initiateFailed()), SIGNAL(InitiateFailed()));
+
+    connect(adaptee, SIGNAL(stateChanged(const QString&)), SIGNAL(StateChanged(const QString&)));
+
+    connect(adaptee, SIGNAL(respondComplete(bool, const QString &)), SIGNAL(RespondComplete(bool, const QString &)));
+}
+
+ConnectionInterfaceUSSDAdaptor::~ConnectionInterfaceUSSDAdaptor()
+{
+}
+
+void ConnectionInterfaceUSSDAdaptor::Initiate(const QString &command, const QDBusMessage& dbusMessage)
+{
+    if (!adaptee()->metaObject()->indexOfMethod("initiate(const QString &,ConnectionInterfaceUSSDAdaptor::InitiateContextPtr)") == -1) {
+        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
+        return;
+    }
+
+    InitiateContextPtr ctx = InitiateContextPtr(
+            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
+    QMetaObject::invokeMethod(adaptee(), "initiate",
+        Q_ARG(QString, command),
+        Q_ARG(ConnectionInterfaceUSSDAdaptor::InitiateContextPtr, ctx));
+    return;
+}
+
+void ConnectionInterfaceUSSDAdaptor::Respond(const QString &reply, const QDBusMessage& dbusMessage)
+{
+    if (!adaptee()->metaObject()->indexOfMethod("respond(QConnectionInterfaceUSSDAdaptor::RespondContextPtr)") == -1) {
+        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
+        return;
+    }
+
+    RespondContextPtr ctx = RespondContextPtr(
+            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
+    QMetaObject::invokeMethod(adaptee(), "respond",
+        Q_ARG(QString, reply),
+        Q_ARG(ConnectionInterfaceUSSDAdaptor::RespondContextPtr, ctx));
+    return;
+}
+
+void ConnectionInterfaceUSSDAdaptor::Cancel(const QDBusMessage& dbusMessage)
+{
+    if (!adaptee()->metaObject()->indexOfMethod("cancel(ConnectionInterfaceUSSDAdaptor::CancelContextPtr)") == -1) {
+        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
+        return;
+    }
+
+    CancelContextPtr ctx = CancelContextPtr(
+            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
+    QMetaObject::invokeMethod(adaptee(), "cancel",
+        Q_ARG(ConnectionInterfaceUSSDAdaptor::CancelContextPtr, ctx));
+    return;
+}
+
+QString ConnectionInterfaceUSSDAdaptor::Serial() const
+{
+    return qvariant_cast< QString >(adaptee()->property("serial"));
+}
+
+
+QString ConnectionInterfaceUSSDAdaptor::State() const
+{
+    return qvariant_cast< QString >(adaptee()->property("state"));
+}
+

=== added file 'ussdiface.h'
--- ussdiface.h	1970-01-01 00:00:00 +0000
+++ ussdiface.h	2014-04-02 22:00:18 +0000
@@ -0,0 +1,243 @@
+/**
+ * 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 <[e-mail]>
+ */
+
+#ifndef OFONOUSSDIFACE_H
+#define OFONOUSSDIFACE_H
+
+// telepathy-qt
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/BaseConnection>
+#include <TelepathyQt/AbstractAdaptor>
+#include <TelepathyQt/DBusError>
+#include <TelepathyQt/Callbacks>
+
+class BaseConnectionUSSDInterface;
+
+typedef Tp::SharedPtr<BaseConnectionUSSDInterface> BaseConnectionUSSDInterfacePtr;
+
+#define TP_QT_IFACE_CONNECTION_USSD "com.canonical.Telephony.USSD"
+
+class TP_QT_EXPORT BaseConnectionUSSDInterface : public Tp::AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionUSSDInterface)
+
+public:
+    static BaseConnectionUSSDInterfacePtr create() {
+        return BaseConnectionUSSDInterfacePtr(new BaseConnectionUSSDInterface());
+    }
+    template<typename BaseConnectionUSSDInterfaceSubclass>
+    static Tp::SharedPtr<BaseConnectionUSSDInterfaceSubclass> create() {
+        return Tp::SharedPtr<BaseConnectionUSSDInterfaceSubclass>(
+                   new BaseConnectionUSSDInterfaceSubclass());
+    }
+    QVariantMap immutableProperties() const;
+    virtual ~BaseConnectionUSSDInterface();
+
+    typedef Tp::Callback2<void, const QString&, Tp::DBusError*> InitiateCallback;
+    void setInitiateCallback(const InitiateCallback &cb);
+
+    typedef Tp::Callback2<void, const QString&, Tp::DBusError*> RespondCallback;
+    void setRespondCallback(const RespondCallback &cb);
+
+    typedef Tp::Callback1<void, Tp::DBusError*> CancelCallback;
+    void setCancelCallback(const CancelCallback &cb);
+
+
+    QString state() const;
+    QString serial() const;
+    void setSerial(const QString& serial) const;
+
+public Q_SLOTS:
+    void NotificationReceived(const QString &message);
+    void RequestReceived(const QString &message);
+
+    void InitiateUSSDComplete(const QString &ussdResp);
+    void RespondComplete(bool success, const QString &ussdResp);
+    void BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
+    void ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
+    void WaitingComplete(const QString &ssOp, const QVariantMap &cwMap);
+    void CallingLinePresentationComplete(const QString &ssOp, const QString &status);
+    void ConnectedLinePresentationComplete(const QString &ssOp, const QString &status);
+    void CallingLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void InitiateFailed();
+    void StateChanged(const QString &state);
+
+protected:
+    BaseConnectionUSSDInterface();
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+
+class TP_QT_EXPORT ConnectionInterfaceUSSDAdaptor : public Tp::AbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", TP_QT_IFACE_CONNECTION_USSD)
+    Q_CLASSINFO("D-Bus Introspection", ""
+"  <interface name=\"com.canonical.Telephony.USSD\">\n"
+"    <property access=\"read\" type=\"s\" name=\"State\"/>\n"
+"    <property access=\"read\" type=\"s\" name=\"Serial\"/>\n"
+"    <method name=\"Initiate\">\n"
+"      <arg direction=\"in\" type=\"s\" name=\"command\"/>\n"
+"    </method>\n"
+"    <method name=\"Respond\">\n"
+"      <arg direction=\"in\" type=\"s\" name=\"reply\"/>\n"
+"    </method>\n"
+"    <method name=\"Cancel\" />\n"
+"    <signal name=\"NotificationReceived\">\n"
+"      <arg type=\"s\" name=\"message\"/>\n"
+"    </signal>\n"
+"    <signal name=\"RequestReceived\">\n"
+"      <arg type=\"s\" name=\"message\"/>\n"
+"    </signal>\n"
+"    <signal name=\"InitiateUSSDComplete\">\n"
+"      <arg type=\"s\" name=\"response\"/>\n"
+"    </signal>\n"
+"    <signal name=\"RespondComplete\">\n"
+"      <arg type=\"b\" name=\"success\"/>\n"
+"      <arg type=\"s\" name=\"response\"/>\n"
+"    </signal>\n"
+"    <signal name=\"BarringComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"cbService\"/>\n"
+"      <arg type=\"a{sv}\" name=\"cbMap\"/>\n"
+"    </signal>\n"
+"    <signal name=\"ForwardingComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"cfService\"/>\n"
+"      <arg type=\"a{sv}\" name=\"cfMap\"/>\n"
+"    </signal>\n"
+"    <signal name=\"WaitingComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"a{sv}\" name=\"cwMap\"/>\n"
+"    </signal>\n"
+"    <signal name=\"CallingLinePresentationComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"status\"/>\n"
+"    </signal>\n"
+"    <signal name=\"ConnectedLinePresentationComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"status\"/>\n"
+"    </signal>\n"
+"    <signal name=\"CallingLineRestrictionComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"status\"/>\n"
+"    </signal>\n"
+"    <signal name=\"ConnectedLineRestrictionComplete\">\n"
+"      <arg type=\"s\" name=\"ssOp\"/>\n"
+"      <arg type=\"s\" name=\"status\"/>\n"
+"    </signal>\n"
+"    <signal name=\"InitiateFailed\" />\n"
+"    <signal name=\"StateChanged\">\n"
+"      <arg type=\"s\" name=\"state\"/>\n"
+"    </signal>\n"
+"  </interface>\n"
+"")
+    Q_PROPERTY(QString State READ State)
+    Q_PROPERTY(QString Serial READ Serial)
+
+public:
+    ConnectionInterfaceUSSDAdaptor(const QDBusConnection& dbusConnection, QObject* adaptee, QObject* parent);
+    virtual ~ConnectionInterfaceUSSDAdaptor();
+
+    typedef Tp::MethodInvocationContextPtr< > InitiateContextPtr;
+    typedef Tp::MethodInvocationContextPtr< > RespondContextPtr;
+    typedef Tp::MethodInvocationContextPtr< > CancelContextPtr;
+
+public Q_SLOTS: // METHODS
+    void Initiate(const QString &command, const QDBusMessage& dbusMessage);
+    void Respond(const QString &reply, const QDBusMessage& dbusMessage);
+    void Cancel(const QDBusMessage& dbusMessage);
+
+    QString State() const;
+    QString Serial() const;
+
+Q_SIGNALS: // SIGNALS
+    void NotificationReceived(const QString &message);
+    void RequestReceived(const QString &message);
+
+    void InitiateUSSDComplete(const QString &ussdResp);
+    void RespondComplete(bool success, const QString &ussdResp);
+    void BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
+    void ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
+    void WaitingComplete(const QString &ssOp, const QVariantMap &cwMap);
+    void CallingLinePresentationComplete(const QString &ssOp, const QString &status);
+    void ConnectedLinePresentationComplete(const QString &ssOp, const QString &status);
+    void CallingLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void InitiateFailed();
+
+    void StateChanged(const QString &state);
+};
+
+
+class TP_QT_NO_EXPORT BaseConnectionUSSDInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString state READ state)
+    Q_PROPERTY(QString serial READ serial)
+
+public:
+    Adaptee(BaseConnectionUSSDInterface *interface);
+    ~Adaptee();
+    QString state() const
+    {
+        return mInterface->state();
+    }
+    QString serial() const
+    {
+        return mInterface->serial();
+    }
+
+
+private Q_SLOTS:
+    void initiate(const QString &command, const ConnectionInterfaceUSSDAdaptor::InitiateContextPtr &context);
+    void respond(const QString &reply, const ConnectionInterfaceUSSDAdaptor::RespondContextPtr &context);
+    void cancel(const ConnectionInterfaceUSSDAdaptor::CancelContextPtr &context);
+
+Q_SIGNALS:
+    void notificationReceived(const QString &message);
+    void requestReceived(const QString &message);
+
+    void initiateUSSDComplete(const QString &ussdResp);
+    void barringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
+    void forwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
+    void waitingComplete(const QString &ssOp, const QVariantMap &cwMap);
+    void callingLinePresentationComplete(const QString &ssOp, const QString &status);
+    void connectedLinePresentationComplete(const QString &ssOp, const QString &status);
+    void callingLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void connectedLineRestrictionComplete(const QString &ssOp, const QString &status);
+    void initiateFailed();
+    void respondComplete(bool success, const QString &response);
+
+    void stateChanged(const QString &state);
+
+public:
+    BaseConnectionUSSDInterface *mInterface;
+};
+
+#endif