lib/ofonovoicecallmanager.cpp

   1 /*
   2  * This file is part of ofono-qt
   3  *
   4  * Copyright (C) 2010-2011 Nokia Corporation and/or its subsidiary(-ies).
   5  *
   6  * Contact: Alexander Kanavin <alex.kanavin@gmail.com>
   7  *
   8  * Portions of this file are Copyright (C) 2011 Intel Corporation
   9  * Contact: Shane Bryan <shane.bryan@linux.intel.com>
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * version 2.1 as published by the Free Software Foundation.
  14  *
  15  * This library is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  23  * 02110-1301 USA
  24  *
  25  */
  26
  27 #include <QtDBus/QtDBus>
  28 #include <QtCore/QObject>
  29
  30 #include "ofonovoicecallmanager.h"
  31 #include "ofonointerface.h"
  32
  33 #define DIAL_TIMEOUT 30000
  34 #define TONE_TIMEOUT 10000
  35 #define TRANSFER_TIMEOUT 20000
  36 #define SWAP_TIMEOUT 20000
  37 #define HANGUP_TIMEOUT 30000
  38 #define HOLD_TIMEOUT 30000
  39 #define PRIVATE_CHAT_TIMEOUT 30000
  40 #define CREATE_MULTIPARTY_TIMEOUT 30000
  41
  42 QDBusArgument &operator<<(QDBusArgument &argument, const OfonoVoiceCallManagerStruct &call)
  43 {
  44     argument.beginStructure();
  45     argument << call.path << call.properties;
  46     argument.endStructure();
  47     return argument;
  48 }
  49
  50 const QDBusArgument &operator>>(const QDBusArgument &argument, OfonoVoiceCallManagerStruct &call)
  51 {
  52     argument.beginStructure();
  53     argument >> call.path >> call.properties;
  54     argument.endStructure();
  55     return argument;
  56 }
  57
  58 OfonoVoiceCallManager::OfonoVoiceCallManager(OfonoModem::SelectionSetting modemSetting, const QString &modemPath, QObject *parent)
  59     : OfonoModemInterface(modemSetting, modemPath, "org.ofono.VoiceCallManager", OfonoGetAllOnStartup, parent)
  60 {
  61     QDBusReply<OfonoVoiceCallManagerList> reply;
  62     OfonoVoiceCallManagerList calls;
  63
  64     QDBusMessage request;
  65
  66     qDBusRegisterMetaType<OfonoVoiceCallManagerStruct>();
  67     qDBusRegisterMetaType<OfonoVoiceCallManagerList>();
  68
  69     request = QDBusMessage::createMethodCall("org.ofono",
  70                                              path(), m_if->ifname(),
  71                                              "GetCalls");
  72     reply = QDBusConnection::systemBus().call(request);
  73
  74     calls = reply;
  75     foreach(OfonoVoiceCallManagerStruct call, calls) {
  76         m_calllist<< call.path.path();
  77     }
  78
  79     connect(m_if, SIGNAL(propertyChanged(const QString&, const QVariant&)),
  80             this, SLOT(propertyChanged(const QString&, const QVariant&)));
  81
  82     QDBusConnection::systemBus().connect("org.ofono",path(),m_if->ifname(),
  83                                          "CallAdded", this,
  84                                          SLOT(callAddedChanged(const QDBusObjectPath&, const QVariantMap&)));
  85
  86     QDBusConnection::systemBus().connect("org.ofono",path(),m_if->ifname(),
  87                                          "CallRemoved", this,
  88                                          SLOT(callRemovedChanged(const QDBusObjectPath&)));
  89 }
  90
  91 OfonoVoiceCallManager::~OfonoVoiceCallManager()
  92 {
  93 }
  94
  95 void OfonoVoiceCallManager::dial(const QString &number, const QString &callerid_hide)
  96 {
  97     QDBusMessage request;
  98     request = QDBusMessage::createMethodCall("org.ofono",
  99                                              path(), m_if->ifname(),
 100                                              "Dial");
 101     QList<QVariant>arg;
 102     arg.append(QVariant(number));
 103     arg.append(QVariant(callerid_hide));
 104     request.setArguments(arg);
 105     QDBusConnection::systemBus().callWithCallback(request, this,
 106                                         SLOT(dialResp()),
 107                                         SLOT(dialErr(const QDBusError&)),
 108                                         DIAL_TIMEOUT);
 109 }
 110
 111 void OfonoVoiceCallManager::hangupAll()
 112 {
 113     QDBusMessage request;
 114     request = QDBusMessage::createMethodCall("org.ofono",
 115                                              path(), m_if->ifname(),
 116                                              "HangupAll");
 117
 118     QDBusConnection::systemBus().callWithCallback(request, this,
 119                                         SLOT(hangupAllResp()),
 120                                         SLOT(hangupAllErr(const QDBusError&)),
 121                                         HANGUP_TIMEOUT);
 122 }
 123
 124 void OfonoVoiceCallManager::sendTones(const QString &tonestring)
 125 {
 126     QDBusMessage request;
 127     request = QDBusMessage::createMethodCall("org.ofono",
 128                                              path(), m_if->ifname(),
 129                                              "SendTones");
 130     QList<QVariant>arg;
 131     arg.append(QVariant(tonestring));
 132     request.setArguments(arg);
 133
 134     QDBusConnection::systemBus().callWithCallback(request, this,
 135                                         SLOT(sendTonesResp()),
 136                                         SLOT(sendTonesErr(const QDBusError&)),
 137                                         (TONE_TIMEOUT*tonestring.length()));
 138 }
 139
 140 void OfonoVoiceCallManager::transfer()
 141 {
 142     QDBusMessage request;
 143     request = QDBusMessage::createMethodCall("org.ofono",
 144                                              path(), m_if->ifname(),
 145                                              "Transfer");
 146
 147     QDBusConnection::systemBus().callWithCallback(request, this,
 148                                         SLOT(transferResp()),
 149                                         SLOT(transferErr(const QDBusError&)),
 150                                         TRANSFER_TIMEOUT);
 151 }
 152
 153 void OfonoVoiceCallManager::swapCalls()
 154 {
 155     QDBusMessage request;
 156     request = QDBusMessage::createMethodCall("org.ofono",
 157                                              path(), m_if->ifname(),
 158                                              "SwapCalls");
 159
 160     QDBusConnection::systemBus().callWithCallback(request, this,
 161                                         SLOT(swapCallsResp()),
 162                                         SLOT(swapCallsErr(const QDBusError&)),
 163                                         SWAP_TIMEOUT);
 164 }
 165
 166 void OfonoVoiceCallManager::releaseAndAnswer()
 167 {
 168     QDBusMessage request;
 169     request = QDBusMessage::createMethodCall("org.ofono",
 170                                              path(), m_if->ifname(),
 171                                              "ReleaseAndAnswer");
 172
 173     QDBusConnection::systemBus().callWithCallback(request, this,
 174                                         SLOT(releaseAndAnswerResp()),
 175                                         SLOT(releaseAndAnswerErr(const QDBusError&)),
 176                                         HANGUP_TIMEOUT);
 177 }
 178
 179 void OfonoVoiceCallManager::holdAndAnswer()
 180 {
 181     QDBusMessage request;
 182     request = QDBusMessage::createMethodCall("org.ofono",
 183                                              path(), m_if->ifname(),
 184                                              "HoldAndAnswer");
 185
 186     QDBusConnection::systemBus().callWithCallback(request, this,
 187                                         SLOT(holdAndAnswerResp()),
 188                                         SLOT(holdAndAnswerErr(const QDBusError&)),
 189                                         HOLD_TIMEOUT);
 190 }
 191
 192 void OfonoVoiceCallManager::privateChat(const QString &call)
 193 {
 194     QDBusMessage request;
 195     request = QDBusMessage::createMethodCall("org.ofono",
 196                                              path(), m_if->ifname(),
 197                                              "PrivateChat");
 198
 199     QList<QVariant>arg;
 200     arg.append(qVariantFromValue(QDBusObjectPath(call)));
 201     request.setArguments(arg);
 202     QDBusConnection::systemBus().callWithCallback(request, this,
 203                                         SLOT(privateChatResp()),
 204                                         SLOT(privateChatErr(const QDBusError&)),
 205                                         PRIVATE_CHAT_TIMEOUT);
 206 }
 207
 208 void OfonoVoiceCallManager::createMultiparty()
 209 {
 210     QDBusMessage request;
 211     request = QDBusMessage::createMethodCall("org.ofono",
 212                                              path(), m_if->ifname(),
 213                                              "CreateMultiparty");
 214
 215     QDBusConnection::systemBus().callWithCallback(request, this,
 216                                         SLOT(createMultipartyResp()),
 217                                         SLOT(createMultipartyErr(const QDBusError&)),
 218                                         CREATE_MULTIPARTY_TIMEOUT);
 219 }
 220
 221 void OfonoVoiceCallManager::hangupMultiparty()
 222 {
 223     QDBusMessage request;
 224     request = QDBusMessage::createMethodCall("org.ofono",
 225                                              path(), m_if->ifname(),
 226                                              "HangupMultiparty");
 227
 228     QDBusConnection::systemBus().callWithCallback(request, this,
 229                                         SLOT(hangupMultipartyResp()),
 230                                         SLOT(hangupMultipartyErr(const QDBusError&)),
 231                                         HANGUP_TIMEOUT);
 232 }
 233
 234 void OfonoVoiceCallManager::hangupMultipartyResp()
 235 {
 236     emit hangupMultipartyComplete(TRUE);
 237 }
 238
 239 void OfonoVoiceCallManager::hangupMultipartyErr(const QDBusError &error)
 240 {
 241     m_if->setError(error.name(), error.message());
 242     emit hangupMultipartyComplete(FALSE);
 243 }
 244
 245 void OfonoVoiceCallManager::createMultipartyResp()
 246 {
 247     emit createMultipartyComplete(TRUE);
 248 }
 249
 250 void OfonoVoiceCallManager::createMultipartyErr(const QDBusError &error)
 251 {
 252     m_if->setError(error.name(), error.message());
 253     emit createMultipartyComplete(FALSE);
 254 }
 255
 256 void OfonoVoiceCallManager::privateChatResp()
 257 {
 258     emit privateChatComplete(TRUE);
 259 }
 260
 261 void OfonoVoiceCallManager::privateChatErr(const QDBusError &error)
 262 {
 263     m_if->setError(error.name(), error.message());
 264     emit privateChatComplete(FALSE);
 265 }
 266
 267 void OfonoVoiceCallManager::holdAndAnswerResp()
 268 {
 269     emit holdAndAnswerComplete(TRUE);
 270 }
 271
 272 void OfonoVoiceCallManager::holdAndAnswerErr(const QDBusError &error)
 273 {
 274     m_if->setError(error.name(), error.message());
 275     emit holdAndAnswerComplete(FALSE);
 276 }
 277
 278 void OfonoVoiceCallManager::releaseAndAnswerResp()
 279 {
 280     emit releaseAndAnswerComplete(TRUE);
 281 }
 282
 283 void OfonoVoiceCallManager::releaseAndAnswerErr(const QDBusError &error)
 284 {
 285     m_if->setError(error.name(), error.message());
 286     emit releaseAndAnswerComplete(FALSE);
 287 }
 288
 289 void OfonoVoiceCallManager::swapCallsResp()
 290 {
 291     emit swapCallsComplete(TRUE);
 292 }
 293
 294 void OfonoVoiceCallManager::swapCallsErr(const QDBusError &error)
 295 {
 296     m_if->setError(error.name(), error.message());
 297     emit swapCallsComplete(FALSE);
 298 }
 299
 300 void OfonoVoiceCallManager::dialResp()
 301 {
 302     emit dialComplete(TRUE);
 303 }
 304
 305 void OfonoVoiceCallManager::dialErr(const QDBusError &error)
 306 {
 307     m_if->setError(error.name(), error.message());
 308     emit dialComplete(FALSE);
 309 }
 310
 311 void OfonoVoiceCallManager::hangupAllResp()
 312 {
 313     emit hangupAllComplete(TRUE);
 314 }
 315
 316 void OfonoVoiceCallManager::hangupAllErr(const QDBusError &error)
 317 {
 318     m_if->setError(error.name(), error.message());
 319     emit hangupAllComplete(FALSE);
 320 }
 321 void OfonoVoiceCallManager::sendTonesResp()
 322 {
 323     emit sendTonesComplete(TRUE);
 324 }
 325
 326 void OfonoVoiceCallManager::sendTonesErr(const QDBusError &error)
 327 {
 328     m_if->setError(error.name(), error.message());
 329     emit sendTonesComplete(FALSE);
 330 }
 331
 332 void OfonoVoiceCallManager::transferResp()
 333 {
 334     emit transferComplete(TRUE);
 335 }
 336
 337 void OfonoVoiceCallManager::transferErr(const QDBusError &error)
 338 {
 339     m_if->setError(error.name(), error.message());
 340     emit transferComplete(FALSE);
 341 }
 342
 343 QStringList OfonoVoiceCallManager::emergencyNumbers() const
 344 {
 345     return m_if->properties()["EmergencyNumbers"].value<QStringList>();
 346 }
 347
 348 void OfonoVoiceCallManager::propertyChanged(const QString &property, const QVariant &value)
 349 {
 350     if (property == "EmergencyNumbers") {
 351         emit emergencyNumbersChanged(value.value<QStringList>());
 352     }
 353 }
 354
 355 QStringList OfonoVoiceCallManager::getCalls() const
 356 {
 357     return m_calllist;
 358 }
 359
 360 void OfonoVoiceCallManager::callAddedChanged(const QDBusObjectPath &path, const QVariantMap& /*values*/)
 361 {
 362     m_calllist << path.path();
 363     emit callAdded(path.path());
 364 }
 365
 366 void OfonoVoiceCallManager::callRemovedChanged(const QDBusObjectPath &path)
 367 {
 368     m_calllist.removeAll(path.path());
 369     emit callRemoved(path.path());
 370 }