Add Missing multiparty bindings (BMC# 18436)

Signed-off-by: Shane Bryan <shane.bryan@linux.intel.com>

diff --git a/lib/ofonovoicecallmanager.cpp b/lib/ofonovoicecallmanager.cpp
index 5ff48bb..6b14dac 100644 (file)
--- a/lib/ofonovoicecallmanager.cpp
+++ b/lib/ofonovoicecallmanager.cpp
@@ -5,6 +5,9 @@
  *
  * Contact: Alexander Kanavin <alexander.kanavin@nokia.com>
  *
+ * Portions of this file are Copyright (C) 2011 Intel Corporation
+ * Contact: Shane Bryan <shane.bryan@linux.intel.com>
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * version 2.1 as published by the Free Software Foundation.
@@ -33,6 +36,8 @@
 #define SWAP_TIMEOUT 20000
 #define HANGUP_TIMEOUT 30000
 #define HOLD_TIMEOUT 30000
+#define PRIVATE_CHAT_TIMEOUT 30000
+#define CREATE_MULTIPARTY_TIMEOUT 30000
 
 QDBusArgument &operator<<(QDBusArgument &argument, const OfonoVoiceCallManagerStruct &call)
 {
@@ -184,6 +189,81 @@ void OfonoVoiceCallManager::holdAndAnswer()
                                         HOLD_TIMEOUT);
 }
 
+void OfonoVoiceCallManager::privateChat(const QString &call)
+{
+    QDBusMessage request;
+    request = QDBusMessage::createMethodCall("org.ofono",
+                                             path(), m_if->ifname(),
+                                             "PrivateChat");
+
+    QList<QVariant>arg;
+    arg.append(qVariantFromValue(QDBusObjectPath(call)));
+    request.setArguments(arg);
+    QDBusConnection::systemBus().callWithCallback(request, this,
+                                        SLOT(privateChatResp()),
+                                        SLOT(privateChatErr(const QDBusError&)),
+                                        PRIVATE_CHAT_TIMEOUT);
+}
+
+void OfonoVoiceCallManager::createMultiparty()
+{
+    QDBusMessage request;
+    request = QDBusMessage::createMethodCall("org.ofono",
+                                             path(), m_if->ifname(),
+                                             "CreateMultiparty");
+
+    QDBusConnection::systemBus().callWithCallback(request, this,
+                                        SLOT(createMultipartyResp()),
+                                        SLOT(createMultipartyErr(const QDBusError&)),
+                                        CREATE_MULTIPARTY_TIMEOUT);
+}
+
+void OfonoVoiceCallManager::hangupMultiparty()
+{
+    QDBusMessage request;
+    request = QDBusMessage::createMethodCall("org.ofono",
+                                             path(), m_if->ifname(),
+                                             "HangupMultiparty");
+
+    QDBusConnection::systemBus().callWithCallback(request, this,
+                                        SLOT(hangupMultipartyResp()),
+                                        SLOT(hangupMultipartyErr(const QDBusError&)),
+                                        HANGUP_TIMEOUT);
+}
+
+void OfonoVoiceCallManager::hangupMultipartyResp()
+{
+    emit hangupMultipartyComplete(TRUE);
+}
+
+void OfonoVoiceCallManager::hangupMultipartyErr(const QDBusError &error)
+{
+    m_if->setError(error.name(), error.message());
+    emit hangupMultipartyComplete(FALSE);
+}
+
+void OfonoVoiceCallManager::createMultipartyResp()
+{
+    emit createMultipartyComplete(TRUE);
+}
+
+void OfonoVoiceCallManager::createMultipartyErr(const QDBusError &error)
+{
+    m_if->setError(error.name(), error.message());
+    emit createMultipartyComplete(FALSE);
+}
+
+void OfonoVoiceCallManager::privateChatResp()
+{
+    emit privateChatComplete(TRUE);
+}
+
+void OfonoVoiceCallManager::privateChatErr(const QDBusError &error)
+{
+    m_if->setError(error.name(), error.message());
+    emit privateChatComplete(FALSE);
+}
+
 void OfonoVoiceCallManager::holdAndAnswerResp()
 {
     emit holdAndAnswerComplete(TRUE);

diff --git a/lib/ofonovoicecallmanager.h b/lib/ofonovoicecallmanager.h
index 725b586..e76c739 100644 (file)
--- a/lib/ofonovoicecallmanager.h
+++ b/lib/ofonovoicecallmanager.h
@@ -5,6 +5,9 @@
  *
  * Contact: Alexander Kanavin <alexander.kanavin@nokia.com>
  *
+ * Portions of this file are Copyright (C) 2011 Intel Corporation
+ * Contact: Shane Bryan <shane.bryan@linux.intel.com>
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * version 2.1 as published by the Free Software Foundation.
@@ -69,6 +72,9 @@ public slots:
     void swapCalls();
     void releaseAndAnswer();
     void holdAndAnswer();
+    void privateChat(const QString &path);
+    void createMultiparty();
+    void hangupMultiparty();
 
 signals:
     void emergencyNumbersChanged(const QStringList &numbers);
@@ -81,6 +87,9 @@ signals:
     void swapCallsComplete(const bool status);
     void releaseAndAnswerComplete(const bool status);
     void holdAndAnswerComplete(const bool status);
+    void privateChatComplete(const bool status);
+    void createMultipartyComplete(const bool status);
+    void hangupMultipartyComplete(const bool status);
 
 private slots:
     void propertyChanged(const QString &property, const QVariant &value);
@@ -100,6 +109,12 @@ private slots:
     void releaseAndAnswerErr(const QDBusError &error);
     void holdAndAnswerResp();
     void holdAndAnswerErr(const QDBusError &error);
+    void privateChatResp();
+    void privateChatErr(const QDBusError &error);
+    void createMultipartyResp();
+    void createMultipartyErr(const QDBusError &error);
+    void hangupMultipartyResp();
+    void hangupMultipartyErr(const QDBusError &error);
 
 
 private:

diff --git a/tests/test_ofonomultipartycall.cpp b/tests/test_ofonomultipartycall.cpp
new file mode 100644 (file)
index 0000000..8ddf6f2
--- /dev/null
+++ b/tests/test_ofonomultipartycall.cpp
@@ -0,0 +1,341 @@
+/*
+ * This file is part of ofono-qt
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: Alexander Kanavin <alexander.kanavin@nokia.com>
+ *
+ * Portions of this file are Copyright (C) 2011 Intel Corporation
+ * Contact: Shane Bryan <shane.bryan@linux.intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <QtTest/QtTest>
+#include <QtCore/QObject>
+
+#include <ofonovoicecallmanager.h>
+#include <ofonovoicecall.h>
+#include <QtDebug>
+
+class TestOfonoMultipartyCall : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase()
+    {
+        m = new OfonoVoiceCallManager(OfonoModem::ManualSelect, "/phonesim", this);
+        QCOMPARE(m->modem()->isValid(), true);
+        if (!m->modem()->powered()) {
+            m->modem()->setPowered(true);
+            QTest::qWait(5000);
+        }
+        if (!m->modem()->online()) {
+            m->modem()->setOnline(true);
+            QTest::qWait(5000);
+        }
+        QCOMPARE(m->isValid(), true);
+    }
+
+    void testOfonoMultipartyCalls()
+    {
+        // Test for hangupMultiparty():
+        // 1.  Dial a call
+        // 2.  Receive a call (dial "199" to trigger phonesim callback)
+        // 3.  Combine into multiparty call (2 participants)
+        // 4.  Verify createMultiparty() works as expected
+        // 5.  Put multiparty call on hold
+        // 6.  Dial a 3rd call
+        // 7.  Combine into multiparty call (3 participants)
+        // 8.  Split one call off to "private chat"
+        // 9.  Verify privateChat() works as expected
+        // 10. Hangup multiparty call
+        // 11. Verify hangupMultiparty() works as expected
+        // 12. Hangup all calls
+
+        // VoiceCallManager Spy's
+        QSignalSpy dialreg(m,SIGNAL(dialComplete(bool)));
+        QSignalSpy dspy(m, SIGNAL(callAdded(QString)));
+        QSignalSpy rspy(m, SIGNAL(callRemoved(QString)));
+        QSignalSpy haspy(m, SIGNAL(hangupAllComplete(bool)));
+        QSignalSpy haaspy(m, SIGNAL(holdAndAnswerComplete(bool)));
+        QSignalSpy cmspy(m, SIGNAL(createMultipartyComplete(bool)));
+        QSignalSpy hmspy(m, SIGNAL(hangupMultipartyComplete(bool)));
+        QSignalSpy scspy(m, SIGNAL(swapCallsComplete(bool)));
+        QSignalSpy pcspy(m, SIGNAL(privateChatComplete(bool)));
+
+        // 1. Dial a call (outgoing)
+        m->dial("123","");
+        QTest::qWait(1000);
+
+        QCOMPARE(dialreg.count(), 1);
+        QCOMPARE(dialreg.takeFirst().at(0).toBool(),true);
+        QCOMPARE(dspy.count(), 1);
+        QString c1id = dspy.takeFirst().at(0).toString();
+
+        OfonoVoiceCall* c1 = new OfonoVoiceCall(c1id);
+
+        QSignalSpy c1state(c1, SIGNAL(stateChanged(const QString)));
+        QSignalSpy c1discreason(c1,SIGNAL(disconnectReason(const QString)));
+        QSignalSpy c1li (c1, SIGNAL(lineIdentificationChanged(QString)));
+        QSignalSpy c1name (c1, SIGNAL(nameChanged(QString)));
+        QSignalSpy c1info (c1, SIGNAL(informationChanged(QString)));
+        QSignalSpy c1mp (c1, SIGNAL(multipartyChanged(bool)));
+        QSignalSpy c1em (c1, SIGNAL(emergencyChanged(bool)));
+        QSignalSpy c1st (c1, SIGNAL(startTimeChanged(QString)));
+        QSignalSpy c1ic (c1, SIGNAL(iconChanged(quint8)));
+
+        QTest::qWait(3000);
+        //    - new call should have a state change, and be in "active" state
+        QVERIFY(c1state.count()>0);
+        QVERIFY(c1st.count()>0);
+        QVERIFY(c1ic.count()==0);
+        QVERIFY(c1em.count()==0);
+        QVERIFY(c1mp.count()==0);
+        QVERIFY(c1info.count()==0);
+        QVERIFY(c1name.count()==0);
+        QVERIFY(c1li.count()==0);
+
+        QCOMPARE(c1->state(),QString("active"));
+        QCOMPARE(c1->lineIdentification(),QString("123"));
+        QCOMPARE(c1->emergency(),false);
+        QCOMPARE(c1->multiparty(),false);
+        QCOMPARE(c1->name(),QString(""));
+        QCOMPARE(c1->information(),QString(""));
+
+        // 2. Receive a call
+        //    - dial "199" to trigger phonesim callback
+        m->dial("199","");
+        QTest::qWait(8000);
+
+        QCOMPARE(dialreg.count(), 1);
+        QCOMPARE(dialreg.takeFirst().at(0).toBool(),false);
+        QCOMPARE(dspy.count(),1);
+        QString c2id = dspy.takeFirst().at(0).toString();
+
+        OfonoVoiceCall* c2 = new OfonoVoiceCall(c2id);
+        QSignalSpy c2state(c2, SIGNAL(stateChanged(const QString)));
+        QSignalSpy c2time(c2,SIGNAL(startTimeChanged(const QString)));
+        QSignalSpy c2discreason(c2,SIGNAL(disconnectReason(const QString)));
+
+        QSignalSpy c2li (c2, SIGNAL(lineIdentificationChanged(QString)));
+        QSignalSpy c2name (c2, SIGNAL(nameChanged(QString)));
+        QSignalSpy c2info (c2, SIGNAL(informationChanged(QString)));
+        QSignalSpy c2mp (c2, SIGNAL(multipartyChanged(bool)));
+        QSignalSpy c2em (c2, SIGNAL(emergencyChanged(bool)));
+        QSignalSpy c2ic (c2, SIGNAL(iconChanged(quint8)));
+
+        QTest::qWait(3000);
+        QCOMPARE(c2->state(),QString("waiting"));
+
+        //    - accept incoming call, placing first call on hold
+        m->holdAndAnswer();
+        QTest::qWait(1000);
+
+        QCOMPARE(haaspy.count(),1);
+        QCOMPARE(haaspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        //    - call #1 should be in "held" state
+        QVERIFY(c1state.count()>0);
+        QCOMPARE(c1->state(),QString("held"));
+
+        //    - call #2 should be in "active" state
+        QVERIFY(c2state.count()>0);
+        QCOMPARE(c2->state(),QString("active"));
+        QCOMPARE(c2->lineIdentification(),QString("1234567"));
+        QVERIFY(c2time.count()>0);
+
+        QVERIFY(c2ic.count()==0);
+        QVERIFY(c2em.count()==0);
+        QVERIFY(c2mp.count()==0);
+        QVERIFY(c2info.count()==0);
+        QVERIFY(c2name.count()==0);
+        QVERIFY(c2li.count()==0);
+
+        // 3. Combine into multiparty call (2 participants)
+        m->createMultiparty();
+        QTest::qWait(1000);
+        QCOMPARE(cmspy.count(),1);
+        QCOMPARE(cmspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        // 4. Verify createMultiparty() works as expected
+        //    - call #1 should have a stateChanged signal triggered
+        QVERIFY(c1state.count()>0);
+        //    - both calls should have a multipartyChanged signal triggered,
+        //      be in "active" state and have multiparty property set to "true"
+        QVERIFY(c1mp.count()>0);
+        QVERIFY(c2mp.count()>0);
+        QCOMPARE(c1->state(),QString("active"));
+        QCOMPARE(c2->state(),QString("active"));
+        QCOMPARE(c1->multiparty(),true);
+        QCOMPARE(c2->multiparty(),true);
+
+        // 5. Put multiparty call on hold
+        m->swapCalls();
+        QTest::qWait(1000);
+
+        QCOMPARE(scspy.count(),1);
+        QCOMPARE(scspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        //    - both calls should have a stateChanged signal triggered
+        //      and be in "held" state
+        QVERIFY(c1state.count()>0);
+        QVERIFY(c2state.count()>0);
+        QCOMPARE(c1->state(),QString("held"));
+        QCOMPARE(c2->state(),QString("held"));
+
+        // 6. Dial a 3rd call
+        m->dial("456","");
+        QTest::qWait(1000);
+
+        QCOMPARE(dialreg.count(), 1);
+        QCOMPARE(dialreg.takeFirst().at(0).toBool(),true);
+        QCOMPARE(dspy.count(), 1);
+        QString c3id = dspy.takeFirst().at(0).toString();
+
+        OfonoVoiceCall* c3 = new OfonoVoiceCall(c3id);
+
+        QSignalSpy c3state(c3, SIGNAL(stateChanged(const QString)));
+        QSignalSpy c3discreason(c3,SIGNAL(disconnectReason(const QString)));
+        QSignalSpy c3li (c3, SIGNAL(lineIdentificationChanged(QString)));
+        QSignalSpy c3name (c3, SIGNAL(nameChanged(QString)));
+        QSignalSpy c3info (c3, SIGNAL(informationChanged(QString)));
+        QSignalSpy c3mp (c3, SIGNAL(multipartyChanged(bool)));
+        QSignalSpy c3em (c3, SIGNAL(emergencyChanged(bool)));
+        QSignalSpy c3st (c3, SIGNAL(startTimeChanged(QString)));
+        QSignalSpy c3ic (c3, SIGNAL(iconChanged(quint8)));
+
+        QTest::qWait(3000);
+        //    - 3rd call should have a state change, and be in "active" state
+        QVERIFY(c3state.count()>0);
+        QVERIFY(c3st.count()>0);
+        QVERIFY(c3ic.count()==0);
+        QVERIFY(c3em.count()==0);
+        QVERIFY(c3mp.count()==0);
+        QVERIFY(c3info.count()==0);
+        QVERIFY(c3name.count()==0);
+        QVERIFY(c3li.count()==0);
+
+        QCOMPARE(c3->state(),QString("active"));
+        QCOMPARE(c3->lineIdentification(),QString("456"));
+        QCOMPARE(c3->emergency(),false);
+        QCOMPARE(c3->multiparty(),false);
+        QCOMPARE(c3->name(),QString(""));
+        QCOMPARE(c3->information(),QString(""));
+
+        // 7. Combine into multiparty call (3 participants)
+        m->createMultiparty();
+        QTest::qWait(1000);
+
+        QCOMPARE(cmspy.count(),1);
+        QCOMPARE(cmspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        //    - calls #1 and #2 should have a stateChanged signal triggered
+        QVERIFY(c1state.count()>0);
+        QVERIFY(c2state.count()>0);
+        //    - all calls should have a multipartyChanged signal triggered,
+        //      be in "active" state and have multiparty property set to "true"
+        QVERIFY(c1mp.count()>0);
+        QVERIFY(c2mp.count()>0);
+        QVERIFY(c3mp.count()>0);
+        QCOMPARE(c1->state(),QString("active"));
+        QCOMPARE(c2->state(),QString("active"));
+        QCOMPARE(c3->state(),QString("active"));
+        QCOMPARE(c1->multiparty(),true);
+        QCOMPARE(c2->multiparty(),true);
+        QCOMPARE(c3->multiparty(),true);
+
+        // 8.  Split call #1 off to "private chat"
+        m->privateChat(c1id);
+        QTest::qWait(1000);
+
+        QCOMPARE(pcspy.count(),1);
+        QCOMPARE(pcspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        // 9.  Verify privateChat() works as expected
+        //    - call #1 should have a multipartyChanged signal triggered,
+        //      it's multiparty property set to false and be in "active" state
+        QVERIFY(c1mp.count()>0);
+        QCOMPARE(c1->multiparty(),false);
+        QCOMPARE(c1->state(),QString("active"));
+        //    - calls #2 and #3 should have a stateChanged signal triggered
+        //      and be back in "held" state
+        QVERIFY(c2state.count()>0);
+        QVERIFY(c3state.count()>0);
+        QCOMPARE(c2->state(),QString("held"));
+        QCOMPARE(c3->state(),QString("held"));
+
+
+        // 10. Hangup multiparty call
+        m->hangupMultiparty();
+        QTest::qWait(1000);
+        QCOMPARE(hmspy.count(), 1);
+        QCOMPARE(hmspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        // 11. Verify hangupMultiparty() works as expected
+        //    - two calls should have been removed
+        QVERIFY(rspy.count()==2);
+        QString r2id = rspy.takeFirst().at(0).toString();
+        QString r3id = rspy.takeFirst().at(0).toString();
+        QCOMPARE(r2id,c2id);
+        QCOMPARE(r3id,c3id);
+
+        //    - call #1 should still be in "active" state
+        QCOMPARE(c1->state(),QString("active"));
+
+        //    - calls #2 and #3 should have a stateChanged signal triggered
+        //      and have a disconnect reason of "local"
+        QVERIFY(c2state.count()>0);
+        QVERIFY(c3state.count()>0);
+        QCOMPARE(c2discreason.count(), 1);
+        QCOMPARE(c3discreason.count(), 1);
+        QCOMPARE(c2discreason.takeFirst().at(0).toString(), QString("local"));
+        QCOMPARE(c3discreason.takeFirst().at(0).toString(), QString("local"));
+
+        // 12. Hangup all calls
+        m->hangupAll();
+        QTest::qWait(1000);
+        QCOMPARE(haspy.count(), 1);
+        QCOMPARE(haspy.takeFirst().at(0).toBool(),true);
+
+        QTest::qWait(3000);
+        QCOMPARE(c1discreason.count(), 1);
+        QCOMPARE(c1discreason.takeFirst().at(0).toString(), QString("local"));
+
+        delete c1;
+        delete c2;
+        delete c3;
+    }
+
+    void cleanupTestCase()
+    {
+
+    }
+
+
+private:
+    OfonoVoiceCallManager *m;
+};
+
+QTEST_MAIN(TestOfonoMultipartyCall)
+#include "test_ofonomultipartycall.moc"

diff --git a/tests/test_ofonomultipartycall.pro b/tests/test_ofonomultipartycall.pro
new file mode 100644 (file)
index 0000000..d02b5b4
--- /dev/null
+++ b/tests/test_ofonomultipartycall.pro
@@ -0,0 +1,2 @@
+include(testcase.pri)
+SOURCES += test_ofonomultipartycall.cpp

diff --git a/tests/tests.pro b/tests/tests.pro
index 06a6820..225bc5c 100644 (file)
--- a/tests/tests.pro
+++ b/tests/tests.pro
@@ -19,4 +19,5 @@ SUBDIRS += test_ofonovoicecallmanager.pro
 SUBDIRS += test_ofonovoicecall.pro
 SUBDIRS += test_ofonocallvolume.pro
 SUBDIRS += test_ofonoconnman.pro
-SUBDIRS += test_ofonoconnmancontext.pro
\ No newline at end of file
+SUBDIRS += test_ofonoconnmancontext.pro
+SUBDIRS += test_ofonomultipartycall.pro