Merge lp:~tiagosh/telephony-service/ussd into lp:telephony-service

[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/telepathy-ofono/ussd/+merge/213936
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/telephony-service) 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)]

FAILED: Continuous integration, rev:793
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/160/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-amd64-ci/84/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/88
        deb: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/88/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-i386-ci/84

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telephony-service-ci/160/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:793
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/161/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-amd64-ci/86
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/89
        deb: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-armhf-ci/89/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telephony-service-trusty-i386-ci/85

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telephony-service-ci/161/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-03-11 21:18:38 +0000
+++ CMakeLists.txt	2014-04-02 22:00:02 +0000
@@ -74,6 +74,7 @@
 
 add_definitions(-std=c++11)
 
+set(DATA_DIR "${CMAKE_SOURCE_DIR}/data")
 # install assets
 set(ASSETS_DIR assets)
 install(DIRECTORY ${ASSETS_DIR} DESTINATION ${TELEPHONY_SERVICE_DIR})

=== modified file 'Ubuntu/Telephony/components.cpp'
--- Ubuntu/Telephony/components.cpp	2014-01-20 12:57:43 +0000
+++ Ubuntu/Telephony/components.cpp	2014-04-02 22:00:02 +0000
@@ -24,6 +24,7 @@
 #include "telepathyhelper.h"
 #include "callentry.h"
 #include "callmanager.h"
+#include "ussdmanager.h"
 #include "channelobserver.h"
 #include "chatmanager.h"
 #include "contactwatcher.h"
@@ -53,6 +54,7 @@
     mRootContext->setContextProperty("telepathyHelper", TelepathyHelper::instance());
     mRootContext->setContextProperty("chatManager", ChatManager::instance());
     mRootContext->setContextProperty("callManager", CallManager::instance());
+    mRootContext->setContextProperty("ussdManager", USSDManager::instance());
 
 }
 

=== added directory 'data'
=== added file 'data/org.freedesktop.Notifications.xml'
--- data/org.freedesktop.Notifications.xml	1970-01-01 00:00:00 +0000
+++ data/org.freedesktop.Notifications.xml	2014-04-02 22:00:02 +0000
@@ -0,0 +1,47 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.freedesktop.Notifications">
+    <signal name="NotificationClosed">
+      <arg name="id" type="u" direction="out"/>
+      <arg name="reason" type="u" direction="out"/>
+    </signal>
+    <signal name="ActionInvoked">
+      <arg name="id" type="u" direction="out"/>
+      <arg name="action_key" type="s" direction="out"/>
+    </signal>
+    <signal name="dataChanged">
+      <arg name="id" type="u" direction="out"/>
+    </signal>
+    <method name="CloseNotification">
+      <arg name="id" type="u" direction="in"/>
+    </method>
+    <method name="GetServerInformation">
+      <arg name="name" type="s" direction="out"/>
+      <arg name="vendor" type="s" direction="out"/>
+      <arg name="version" type="s" direction="out"/>
+      <arg name="specVersion" type="s" direction="out"/>
+    </method>
+    <method name="GetCapabilities">
+      <arg type="as" direction="out"/>
+    </method>
+    <method name="Notify">
+      <arg type="u" direction="out"/>
+      <arg name="app_name" type="s" direction="in"/>
+      <arg name="replaces_id" type="u" direction="in"/>
+      <arg name="app_icon" type="s" direction="in"/>
+      <arg name="summary" type="s" direction="in"/>
+      <arg name="body" type="s" direction="in"/>
+      <arg name="actions" type="as" direction="in"/>
+      <arg name="hints" type="a{sv}" direction="in"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.In6" value="QVariantMap"/>
+      <arg name="expire_timeout" type="i" direction="in"/>
+    </method>
+    <method name="onDataChanged">
+      <arg name="id" type="u" direction="in"/>
+    </method>
+    <method name="onCompleted">
+      <arg name="id" type="u" direction="in"/>
+    </method>
+  </interface>
+</node>

=== modified file 'indicator/CMakeLists.txt'
--- indicator/CMakeLists.txt	2014-01-13 12:10:12 +0000
+++ indicator/CMakeLists.txt	2014-04-02 22:00:02 +0000
@@ -4,9 +4,23 @@
     messagingmenu.cpp
     metrics.cpp
     textchannelobserver.cpp
+    ussdindicator.cpp
+    ussdmenu.cpp
     voicemailindicator.cpp
     )
 
+set_source_files_properties(
+        "${DATA_DIR}/org.freedesktop.Notifications.xml"
+        PROPERTIES
+        INCLUDE "${CMAKE_SOURCE_DIR}/indicator/DBusTypes.h"
+)
+
+qt5_add_dbus_interface(
+        qt_SRCS
+        "${DATA_DIR}/org.freedesktop.Notifications.xml"
+        NotificationsInterface
+)
+
 set(indicator_SRCS main.cpp ${qt_SRCS})
 
 include_directories(

=== added file 'indicator/DBusTypes.h'
--- indicator/DBusTypes.h	1970-01-01 00:00:00 +0000
+++ indicator/DBusTypes.h	2014-04-02 22:00:02 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 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/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ */
+
+#ifndef DBUSTYPES_H_
+#define DBUSTYPES_H_
+
+#include <QDBusMetaType>
+#include <QMap>
+
+typedef QMap<QString, QVariantMap> QVariantDictMap;
+Q_DECLARE_METATYPE(QVariantDictMap)
+
+class DBusTypes {
+public:
+	static void registerMetaTypes() {
+		qRegisterMetaType<QVariantDictMap>("QVariantDictMap");
+		qDBusRegisterMetaType<QVariantDictMap>();
+	}
+};
+
+#endif /* DBUSTYPES_H_ */

=== modified file 'indicator/main.cpp'
--- indicator/main.cpp	2013-09-25 21:18:46 +0000
+++ indicator/main.cpp	2014-04-02 22:00:02 +0000
@@ -28,6 +28,7 @@
 #include "telepathyhelper.h"
 #include "textchannelobserver.h"
 #include "voicemailindicator.h"
+#include "ussdindicator.h"
 #include <QCoreApplication>
 #include <TelepathyQt/ClientRegistrar>
 #include <TelepathyQt/AbstractClient>
@@ -70,6 +71,9 @@
     VoiceMailIndicator voiceMailIndicator;
     Q_UNUSED(voiceMailIndicator);
 
+    USSDIndicator ussdIndicator;
+    Q_UNUSED(ussdIndicator);
+
     // instanciate the metrics helper
     Metrics::instance();
 

=== added file 'indicator/ussdindicator.cpp'
--- indicator/ussdindicator.cpp	1970-01-01 00:00:00 +0000
+++ indicator/ussdindicator.cpp	2014-04-02 22:00:02 +0000
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2014 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/>.
+ */
+
+namespace C {
+#include <libintl.h>
+}
+
+#include <QDebug>
+#include <libnotify/notify.h>
+#include "ringtone.h"
+#include "ussdindicator.h"
+
+USSDIndicator::USSDIndicator(QObject *parent)
+: QObject(parent),
+  m_menuRequest(true),
+  m_menuNotification(false),
+  m_notifications("org.freedesktop.Notifications",
+                  "/org/freedesktop/Notifications", QDBusConnection::sessionBus())
+{
+    connect(USSDManager::instance(), SIGNAL(notificationReceived(const QString &)), SLOT(onNotificationReceived(const QString &)));
+    connect(USSDManager::instance(), SIGNAL(requestReceived(const QString &)), SLOT(onRequestReceived(const QString &)));
+    connect(USSDManager::instance(), SIGNAL(initiateUSSDComplete(const QString &)), SLOT(onInitiateUSSDComplete(const QString &)));
+    connect(USSDManager::instance(), SIGNAL(respondComplete(bool, const QString &)), SLOT(onRespondComplete(bool, const QString &)));
+    connect(USSDManager::instance(), SIGNAL(stateChanged(const QString &)), SLOT(onStateChanged(const QString &)));
+
+    connect(&m_notifications, SIGNAL(ActionInvoked(uint, const QString &)), this, SLOT(actionInvoked(uint, const QString &)));
+    connect(&m_notifications, SIGNAL(NotificationClosed(uint, uint)), this, SLOT(notificationClosed(uint, uint)));
+}
+
+void USSDIndicator::onNotificationReceived(const QString &message)
+{
+    showUSSDNotification(message, false);
+}
+
+void USSDIndicator::onRequestReceived(const QString &message)
+{
+    showUSSDNotification(message, true);
+}
+
+void USSDIndicator::onInitiateUSSDComplete(const QString &ussdResp)
+{
+    showUSSDNotification(ussdResp, (USSDManager::instance()->state() == "user-response"));
+}
+
+void USSDIndicator::onRespondComplete(bool success, const QString &ussdResp)
+{
+    if (success) {
+        showUSSDNotification(ussdResp, (USSDManager::instance()->state() == "user-response"));
+    }
+}
+
+void USSDIndicator::onStateChanged(const QString &state)
+{
+    // TODO: check if we should close notifications when the state is idle
+}
+
+void USSDIndicator::showUSSDNotification(const QString &message, bool replyRequired)
+{
+    USSDMenu *menu = replyRequired ? &m_menuRequest : &m_menuNotification;
+    QString actionId = "ok_id";
+    QString actionLabel = C::gettext("Ok");
+    if (replyRequired) {
+        actionId = "reply_id";
+        actionLabel = C::gettext("Reply");
+    }
+
+    // indicate to the notification-daemon, that we want to use snap-decisions
+    QVariantMap notificationHints;
+    notificationHints["x-canonical-snap-decisions"] = "true";
+    notificationHints["x-canonical-private-button-tint"] = "true";
+
+    QVariantMap menuModelActions;
+    menuModelActions["notifications"] = menu->actionPath();
+
+    QVariantMap menuModelPaths;
+    menuModelPaths["busName"] = menu->busName();
+    menuModelPaths["menuPath"] = menu->menuPath();
+    menuModelPaths["actions"] = menuModelActions;
+
+    notificationHints["x-canonical-private-menu-model"] = menuModelPaths;
+
+    m_notificationId = m_notifications.Notify("telephony-service-indicator",
+                        0, "",
+                        "", message,
+                        QStringList() << actionId << actionLabel << "cancel_id"
+                                        << C::gettext("Cancel"), notificationHints, 0);
+
+
+    Ringtone::instance()->playIncomingMessageSound();
+}
+
+void USSDIndicator::actionInvoked(uint id, const QString &actionKey) 
+{
+    if (id != m_notificationId) {
+        return;
+    }
+
+    m_notificationId = 0;
+
+    if (actionKey == "reply_id") {
+        USSDManager::instance()->respond(m_menuRequest.response(), USSDManager::instance()->activeAccountId());
+    } else if (actionKey == "cancel_id") {
+        USSDManager::instance()->cancel(USSDManager::instance()->activeAccountId());
+    }
+    m_menuRequest.clearResponse();
+}
+
+void USSDIndicator::notificationClosed(uint id, uint reason) {
+    if (id != m_notificationId) {
+        return;
+    }
+    m_notifications.CloseNotification(m_notificationId);
+    m_notificationId = 0;
+}

=== added file 'indicator/ussdindicator.h'
--- indicator/ussdindicator.h	1970-01-01 00:00:00 +0000
+++ indicator/ussdindicator.h	2014-04-02 22:00:02 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 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 USSDINDICATOR_H
+#define USSDINDICATOR_H
+
+#include <QDBusInterface>
+#include <QVariantMap>
+#include "indicator/NotificationsInterface.h"
+#include "ussdmanager.h"
+#include "ussdmenu.h"
+
+class USSDIndicator : public QObject
+{
+    Q_OBJECT
+public:
+    explicit USSDIndicator(QObject *parent = 0);
+    void showUSSDNotification(const QString &message, bool replyRequired);
+
+public Q_SLOTS:
+    void onNotificationReceived(const QString &message);
+    void onRequestReceived(const QString &message);
+    void onInitiateUSSDComplete(const QString &ussdResp);
+    void onRespondComplete(bool success, const QString &ussdResp);
+    void onStateChanged(const QString &state);
+    void actionInvoked(uint id, const QString &actionKey);
+    void notificationClosed(uint id, uint reason);
+private:
+    unsigned int m_notificationId;
+    USSDMenu m_menuRequest;
+    USSDMenu m_menuNotification;
+    QString mPendingMessage;
+    org::freedesktop::Notifications m_notifications;
+};
+
+#endif // USSDINDICATOR_H

=== added file 'indicator/ussdmenu.cpp'
--- indicator/ussdmenu.cpp	1970-01-01 00:00:00 +0000
+++ indicator/ussdmenu.cpp	2014-04-02 22:00:02 +0000
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 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/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ * Author: Tiago Salem Herrmann <[e-mail]>
+ */
+
+#include "ussdmenu.h"
+#include <gio/gio.h>
+
+#include <QString>
+#include <QDebug>
+
+static const QString USSD_ACTION_PATH("/action/%1");
+static const QString USSD_MENU_PATH("/menu/%1");
+
+class USSDMenuPriv {
+public:
+	USSDMenuPriv() :
+			m_connection(g_bus_get_sync(G_BUS_TYPE_SESSION, NULL,
+			NULL)), m_exportedActionGroupId(0), m_exportedMenuModelId(0) {
+	}
+
+	~USSDMenuPriv() {
+		g_object_unref(m_connection);
+	}
+
+	static void responseChangedCallback(GAction *responseAction,
+			GVariant *variant, gpointer userData) {
+		USSDMenuPriv *self(reinterpret_cast<USSDMenuPriv*>(userData));
+		self->m_response = QString::fromUtf8(g_variant_get_string(variant, 0));
+        }
+
+	GDBusConnection *m_connection;
+	QString m_busName;
+	QString m_actionPath;
+	QString m_menuPath;
+	unsigned int m_exportedActionGroupId;
+	unsigned int m_exportedMenuModelId;
+	QString m_response;
+};
+
+USSDMenu::USSDMenu(bool needsResponse) :
+		p(new USSDMenuPriv()) {
+	int exportrev;
+
+	p->m_busName = QString::fromUtf8(
+			g_dbus_connection_get_unique_name(p->m_connection));
+
+	// menu
+	GMenu *menu(g_menu_new());
+
+	GMenuItem *ussdItem(g_menu_item_new("", "notifications.ussd"));
+        if (needsResponse) {
+            g_menu_item_set_attribute_value(ussdItem, "x-canonical-type",
+                            g_variant_new_string("com.canonical.snapdecision.textfield"));
+            g_menu_item_set_attribute_value(ussdItem, "x-echo-mode-password",
+                            g_variant_new_boolean(false));
+            g_menu_append_item(menu, ussdItem);
+        }
+
+	// actions
+	GActionGroup *actions(G_ACTION_GROUP(g_simple_action_group_new()));
+	GAction *ussdAction(G_ACTION(
+			g_simple_action_new_stateful("ussd", G_VARIANT_TYPE_STRING,
+					g_variant_new_string(""))));
+
+	g_signal_connect(G_OBJECT(ussdAction), "change-state",
+			G_CALLBACK(USSDMenuPriv::responseChangedCallback),
+			reinterpret_cast<gpointer>(p.data()));
+
+	g_action_map_add_action(G_ACTION_MAP(actions), ussdAction);
+
+	/* Export the actions group.  If we can't get a name, keep trying to
+	   use increasing numbers.  There is possible races on fast import/exports.
+	   They're rare, but worth protecting against. */
+	exportrev = 0;
+	do {
+		exportrev++;
+		p->m_actionPath = USSD_ACTION_PATH.arg(exportrev);
+		p->m_exportedActionGroupId = g_dbus_connection_export_action_group(
+				p->m_connection, p->m_actionPath.toUtf8().data(), actions, NULL);
+	} while (p->m_exportedActionGroupId == 0 && exportrev < 128);
+
+	/* Export the menu.  If we can't get a name, keep trying to
+	   use increasing numbers.  There is possible races on fast import/exports.
+	   They're rare, but worth protecting against. */
+	exportrev = 0;
+	do {
+		exportrev++;
+		p->m_menuPath = USSD_MENU_PATH.arg(exportrev);
+		p->m_exportedMenuModelId = g_dbus_connection_export_menu_model(
+				p->m_connection, p->m_menuPath.toUtf8().data(),
+				G_MENU_MODEL(menu), NULL);
+	} while (p->m_exportedMenuModelId == 0 && exportrev < 128);
+
+	/* Unref the objects as a reference is maintained by the fact that they're
+	   exported onto the bus. */
+	g_object_unref(menu);
+	g_object_unref(ussdItem);
+
+	g_object_unref(actions);
+	g_object_unref(ussdAction);
+}
+
+USSDMenu::~USSDMenu() {
+	g_dbus_connection_unexport_action_group(p->m_connection,
+			p->m_exportedActionGroupId);
+	g_dbus_connection_unexport_menu_model(p->m_connection,
+			p->m_exportedMenuModelId);
+}
+
+const QString & USSDMenu::busName() const {
+	return p->m_busName;
+}
+
+const QString & USSDMenu::response() const {
+	return p->m_response;
+}
+
+const QString & USSDMenu::actionPath() const {
+	return p->m_actionPath;
+}
+
+const QString & USSDMenu::menuPath() const {
+	return p->m_menuPath;
+}
+
+void USSDMenu::clearResponse() {
+	p->m_response.clear();
+}

=== added file 'indicator/ussdmenu.h'
--- indicator/ussdmenu.h	1970-01-01 00:00:00 +0000
+++ indicator/ussdmenu.h	2014-04-02 22:00:02 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 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/>.
+ *
+ * Author: Pete Woods <[e-mail]>
+ * Author: Tiago Salem Herrmann <[e-mail]>
+ */
+
+#ifndef USSDMENU_H_
+#define USSDMENU_H_
+
+#include <QString>
+#include <QScopedPointer>
+
+class USSDMenuPriv;
+
+class USSDMenu {
+public:
+	USSDMenu(bool needsResponse = false);
+	virtual ~USSDMenu();
+	const QString & busName() const;
+	const QString & response() const;
+	const QString & actionPath() const;
+	const QString & menuPath() const;
+	void clearResponse();
+protected:
+	QScopedPointer<USSDMenuPriv> p;
+};
+
+#endif /* USSDMENU_H_ */

=== modified file 'libtelephonyservice/CMakeLists.txt'
--- libtelephonyservice/CMakeLists.txt	2014-03-11 21:51:57 +0000
+++ libtelephonyservice/CMakeLists.txt	2014-04-02 22:00:02 +0000
@@ -10,6 +10,7 @@
     phoneutils.cpp
     ringtone.cpp
     telepathyhelper.cpp
+    ussdmanager.cpp
     )
 
 include_directories(

=== modified file 'libtelephonyservice/telepathyhelper.h'
--- libtelephonyservice/telepathyhelper.h	2014-03-13 18:07:04 +0000
+++ libtelephonyservice/telepathyhelper.h	2014-04-02 22:00:02 +0000
@@ -33,6 +33,7 @@
 
 #define CANONICAL_TELEPHONY_VOICEMAIL_IFACE "com.canonical.Telephony.Voicemail"
 #define CANONICAL_TELEPHONY_SPEAKER_IFACE "com.canonical.Telephony.Speaker"
+#define CANONICAL_TELEPHONY_USSD_IFACE "com.canonical.Telephony.USSD"
 
 class TelepathyHelper : public QObject
 {

=== added file 'libtelephonyservice/ussdmanager.cpp'
--- libtelephonyservice/ussdmanager.cpp	1970-01-01 00:00:00 +0000
+++ libtelephonyservice/ussdmanager.cpp	2014-04-02 22:00:02 +0000
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2012 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 "ussdmanager.h"
+#include "telepathyhelper.h"
+
+#include <TelepathyQt/ContactManager>
+#include <QDBusInterface>
+
+typedef QMap<QString, QVariant> dbusQMap;
+Q_DECLARE_METATYPE(dbusQMap)
+
+USSDManager *USSDManager::instance()
+{
+    static USSDManager *self = new USSDManager();
+    return self;
+}
+
+USSDManager::USSDManager(QObject *parent)
+: QObject(parent), mActive(false)
+{
+    connect(TelepathyHelper::instance(), SIGNAL(connectedChanged()), SLOT(onConnectedChanged()));
+}
+
+void USSDManager::initiate(const QString &command, const QString &accountId)
+{
+    Tp::AccountPtr account;
+    if (accountId.isNull()) {
+        account = TelepathyHelper::instance()->accounts()[0];
+    } else {
+        account = TelepathyHelper::instance()->accountForId(accountId);
+    }
+
+    Tp::ConnectionPtr conn(account->connection());
+    QString busName = conn->busName();
+    QString objectPath = conn->objectPath();
+    QDBusInterface ussdIface(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE);
+    ussdIface.asyncCall("Initiate", command);
+}
+
+void USSDManager::respond(const QString &reply, const QString &accountId)
+{
+    Tp::AccountPtr account;
+    if (accountId.isNull()) {
+        account = TelepathyHelper::instance()->accounts()[0];
+    } else {
+        account = TelepathyHelper::instance()->accountForId(accountId);
+    }
+
+    Tp::ConnectionPtr conn(account->connection());
+    QString busName = conn->busName();
+    QString objectPath = conn->objectPath();
+    QDBusInterface ussdIface(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE);
+    ussdIface.asyncCall("Respond", reply);
+}
+
+void USSDManager::cancel(const QString &accountId)
+{
+    Tp::AccountPtr account;
+    if (accountId.isNull()) {
+        account = TelepathyHelper::instance()->accounts()[0];
+    } else {
+        account = TelepathyHelper::instance()->accountForId(accountId);
+    }
+
+    Tp::ConnectionPtr conn(account->connection());
+    QString busName = conn->busName();
+    QString objectPath = conn->objectPath();
+    QDBusInterface ussdIface(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE);
+    ussdIface.asyncCall("Cancel");
+}
+
+void USSDManager::disconnectAllSignals(const Tp::ConnectionPtr& conn)
+{
+    QString busName = conn->busName();
+    QString objectPath = conn->objectPath();
+
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "StateChanged", this, SLOT(onStateChanged(QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "RequestReceived", this, SIGNAL(requestReceived(QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "NotificationReceived", this, SIGNAL(notificationReceived(QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "InitiateUSSDComplete", this, SIGNAL(initiateUSSDComplete(QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "RespondComplete", this, SIGNAL(respondComplete(bool, QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "BarringComplete", this, SIGNAL(barringComplete(QString, QString, QVariantMap)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ForwardingComplete", this, SIGNAL(forwardingComplete(QString, QString, QVariantMap)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "WaitingComplete", this, SIGNAL(waitingComplete(QString, QVariantMap)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "CallingLinePresentationComplete", this, SIGNAL(callingLinePresentationComplete(QString, QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "CallingLineRestrictionComplete", this, SIGNAL(callingLineRestrictionComplete(QString, QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ConnectedLineRestrictionComplete", this, SIGNAL(connectedLineRestrictionComplete(QString, QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ConnectedLinePresentationComplete", this, SIGNAL(connectedLinePresentationComplete(QString, QString)));
+    QDBusConnection::sessionBus().disconnect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "InitiateFailed", this, SIGNAL(initiateFailed()));
+}
+void USSDManager::connectAllSignals(const Tp::ConnectionPtr& conn)
+{
+    QString busName = conn->busName();
+    QString objectPath = conn->objectPath();
+
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "StateChanged", this, SLOT(onStateChanged(QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "RequestReceived", this, SIGNAL(requestReceived(QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "NotificationReceived", this, SIGNAL(notificationReceived(QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "InitiateUSSDComplete", this, SIGNAL(initiateUSSDComplete(QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "RespondComplete", this, SIGNAL(respondComplete(bool, QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "BarringComplete", this, SIGNAL(barringComplete(QString, QString, QVariantMap)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ForwardingComplete", this, SIGNAL(forwardingComplete(QString, QString, QVariantMap)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "WaitingComplete", this, SIGNAL(waitingComplete(QString, QVariantMap)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "CallingLinePresentationComplete", this, SIGNAL(callingLinePresentationComplete(QString, QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "CallingLineRestrictionComplete", this, SIGNAL(callingLineRestrictionComplete(QString, QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ConnectedLineRestrictionComplete", this, SIGNAL(connectedLineRestrictionComplete(QString, QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "ConnectedLinePresentationComplete", this, SIGNAL(connectedLinePresentationComplete(QString, QString)));
+    QDBusConnection::sessionBus().connect(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE, "InitiateFailed", this, SIGNAL(initiateFailed()));
+}
+
+
+void USSDManager::onConnectedChanged()
+{
+    // everytime the connection changes we need to check if there is any ongoing ussd session
+    mActive = false;
+    mActiveAccountId = QString::null;
+    mState = QString("idle");
+
+    if (!TelepathyHelper::instance()->connected()) {
+        Q_EMIT stateChanged(mState);
+        Q_EMIT activeChanged();
+        Q_EMIT activeAccountIdChanged();
+        return;
+    }
+
+    Q_FOREACH (const Tp::AccountPtr &account, TelepathyHelper::instance()->accounts()) {
+        // disconnect all and reconnect only the online accounts
+        Tp::ConnectionPtr conn(account->connection());
+        disconnectAllSignals(conn);
+
+        if (TelepathyHelper::instance()->isAccountConnected(account)) {
+            QString busName = conn->busName();
+            QString objectPath = conn->objectPath();
+
+            connectAllSignals(conn);
+
+            QDBusInterface ussdIface(busName, objectPath, CANONICAL_TELEPHONY_USSD_IFACE);
+            mState = ussdIface.property("State").toString();
+            mSerials[account->uniqueIdentifier()] = ussdIface.property("Serial").toString();
+            if (active()) {
+                mActiveAccountId = account->uniqueIdentifier();
+            }
+        }
+    }
+    Q_EMIT stateChanged(mState);
+    Q_EMIT activeChanged();
+    Q_EMIT activeAccountIdChanged();
+}
+
+void USSDManager::onStateChanged(const QString &state)
+{
+    mState = state;
+    Q_EMIT stateChanged(state);
+}
+
+bool USSDManager::active() const
+{
+    return mState != "idle" && !mState.isEmpty();
+}
+
+QString USSDManager::activeAccountId() const
+{
+    return mActiveAccountId;
+}
+
+QString USSDManager::state() const
+{
+    return mState;
+}
+
+QString USSDManager::serial(const QString &accountId) const
+{
+    return mSerials[accountId];
+}

=== added file 'libtelephonyservice/ussdmanager.h'
--- libtelephonyservice/ussdmanager.h	1970-01-01 00:00:00 +0000
+++ libtelephonyservice/ussdmanager.h	2014-04-02 22:00:02 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2012-2013 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 USSDMANAGER_H
+#define USSDMANAGER_H
+
+#include <QtCore/QMap>
+#include <QDBusInterface>
+#include <TelepathyQt/Connection>
+
+class TelepathyHelper;
+
+class USSDManager : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool active 
+               READ active
+               NOTIFY activeChanged)
+    Q_PROPERTY(QString activeAccountId
+               READ activeAccountId
+               NOTIFY activeAccountIdChanged)
+    Q_PROPERTY(QString state 
+               READ state
+               NOTIFY stateChanged)
+public:
+    static USSDManager *instance();
+    Q_INVOKABLE void initiate(const QString &command, const QString &accountId = QString::null);
+    Q_INVOKABLE void respond(const QString &reply, const QString &accountId = QString::null);
+    Q_INVOKABLE void cancel(const QString &accountId = QString::null);
+    Q_INVOKABLE QString serial(const QString& accountId) const;
+
+    bool active() const;
+    QString activeAccountId() const;
+    QString state() const;
+
+public Q_SLOTS:
+    void onConnectedChanged();
+    void onStateChanged(const QString &state);
+
+Q_SIGNALS:
+    void activeChanged();
+    void activeAccountIdChanged();
+    void stateChanged(const QString &state);
+
+    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();
+
+private:
+    explicit USSDManager(QObject *parent = 0);
+   
+    void disconnectAllSignals(const Tp::ConnectionPtr& conn);
+    void connectAllSignals(const Tp::ConnectionPtr& conn);
+
+    bool mActive;
+    QString mActiveAccountId;
+    QString mState;
+    QMap<QString, QString> mSerials;
+};
+
+#endif // USSDMANAGER_H