src/modemproxy.cpp

   1 /*
   2  * hfdialer - Hands Free Voice Call Manager
   3  * Copyright (c) 2012, Intel Corporation.
   4  *
   5  * This program is licensed under the terms and conditions of the
   6  * Apache License, version 2.0.  The full text of the Apache License is at
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  */
  10
  11 #include "modemproxy.h"
  12 #include <QDebug>
  13 #include "common.h"
  14
  15 ModemProxy::ModemProxy(const QString &objectPath)
  16     : org::ofono::Modem(OFONO_SERVICE,
  17                         objectPath,
  18                         QDBusConnection::systemBus()),
  19       m_interfaces(0)
  20 {
  21 TRACE
  22     if (!isValid()) {
  23         qDebug() << "Failed to connect to Ofono: \n\t" << lastError().message();
  24     } else {
  25         m_path = objectPath;
  26         QDBusPendingReply<QVariantMap> reply;
  27         QDBusPendingCallWatcher * watcher;
  28
  29         reply = GetProperties();
  30         watcher = new QDBusPendingCallWatcher(reply);
  31
  32         connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
  33                 this, SLOT(modemDBusGetPropDone(QDBusPendingCallWatcher*)));
  34
  35         connect(this,
  36                 SIGNAL(PropertyChanged(const QString&,const QDBusVariant&)),
  37                 SLOT(propertyChanged(const QString&,const QDBusVariant&)));
  38     }
  39 }
  40
  41 ModemProxy::~ModemProxy()
  42 {
  43 TRACE
  44 }
  45
  46 QStringList ModemProxy::interfaces() const { return m_interfaces; }
  47 QString ModemProxy::path() const { return m_path; }
  48 QString ModemProxy::manufacturer() const { return m_manufacturer; }
  49 QString ModemProxy::model() const { return m_model; }
  50 QString ModemProxy::revision() const { return m_revision; }
  51 QString ModemProxy::serial() const { return m_serial; }
  52 bool    ModemProxy::powered() const { return m_powered; }
  53 bool    ModemProxy::online() const { return m_online; }
  54
  55 void ModemProxy::setPowered(bool is_powered)
  56 {
  57 TRACE
  58     if (m_powered == is_powered)
  59         return;
  60
  61     QVariant powered(is_powered);
  62
  63     QDBusPendingReply<QVariantMap> reply;
  64     reply = SetProperty("Powered", QDBusVariant(powered));
  65
  66     if (reply.isError())
  67         qCritical() << "SetProperty \"Powered\" failed!";
  68 }
  69
  70 void ModemProxy::setOnline(bool is_online)
  71 {
  72 TRACE
  73     if (m_online == is_online)
  74         return;
  75
  76     QDBusPendingReply<QVariantMap> reply;
  77     reply = SetProperty("Online", QDBusVariant(m_online?"true":"false"));
  78     if (reply.isError())
  79         qCritical() << "SetProperty \"Powered\" failed!";
  80     else
  81         m_online = is_online;
  82 }
  83
  84 void ModemProxy::modemDBusGetPropDone(QDBusPendingCallWatcher *call)
  85 {
  86 TRACE
  87     QDBusPendingReply<QVariantMap> reply = *call;
  88
  89     if (reply.isError()) {
  90       // TODO: Handle this properly, by setting states, or disabling features...
  91       qDebug() << "org.ofono.ModemProxy.getProperties() failed: " <<
  92                   reply.error().message();
  93     } else {
  94       QVariantMap properties = reply.value();
  95       m_interfaces = qdbus_cast<QStringList >(properties["Interfaces"]);
  96       m_manufacturer = qdbus_cast<QString>(properties["Manufacturer"]);
  97       m_model = qdbus_cast<QString>(properties["Model"]);
  98       m_powered = qdbus_cast<bool>(properties["Powered"]);
  99       m_revision = qdbus_cast<QString>(properties["Revision"]);
 100       m_serial = qdbus_cast<QString>(properties["Serial"]);
 101       m_online = qdbus_cast<bool>(properties["Online"]);
 102
 103       // First sucessfull GetProperties == connected
 104       if (!m_connected) {
 105           m_connected = true;
 106           emit connected();
 107       }
 108     }
 109 }
 110
 111 void ModemProxy::propertyChanged(const QString &in0, const QDBusVariant &in1)
 112 {
 113 TRACE
 114     qDebug() << "org.ofono.ModemProxy.propertyChanged()"
 115              << in0 << ": " << in1.variant();
 116     if (in0 == "Interfaces") {
 117         m_interfaces = qdbus_cast<QStringList>(in1.variant());
 118         emit interfacesChanged(m_interfaces);
 119     }
 120     else if (in0 == "Powered") {
 121         m_powered = qdbus_cast<bool>(in1.variant());
 122         emit poweredChanged(m_powered);
 123     } else if (in0 == "Online") {
 124         m_online = qdbus_cast<bool>(in1.variant());
 125         emit onlineChanged(m_online);
 126     } else {
 127         qDebug() << QString("Unhandled property \"%1\" changed...").arg(in0);
 128     }
 129 }
 130
 131 /*
 132  * VoicemailProxy (aka MessageWaiting) implementation
 133  */
 134
 135 VoicemailProxy::VoicemailProxy(const QString &objectPath)
 136     : org::ofono::MessageWaiting(OFONO_SERVICE,
 137                                  objectPath,
 138                                  QDBusConnection::systemBus()),
 139                                  m_connected(false)
 140 {
 141 TRACE
 142     if (!isValid()) {
 143         qDebug() << "Failed to connect to Ofono: \n\t" << lastError().message();
 144     } else {
 145         m_path = objectPath;
 146         QDBusPendingReply<QVariantMap> reply;
 147         QDBusPendingCallWatcher * watcher;
 148
 149         reply = GetProperties();
 150         watcher = new QDBusPendingCallWatcher(reply);
 151
 152         connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
 153                 this, SLOT(voicemailDBusGetPropDone(QDBusPendingCallWatcher*)));
 154         connect(this, SIGNAL(PropertyChanged(const QString&, const QDBusVariant&)),
 155                 SLOT(voicemailPropertyChanged(const QString&, const QDBusVariant&)));
 156     }
 157 }
 158
 159 VoicemailProxy::~VoicemailProxy()
 160 {
 161 TRACE
 162 }
 163
 164 bool    VoicemailProxy::isConnected() const { return m_connected; }
 165 QString VoicemailProxy::path() const { return m_path; }
 166 QString VoicemailProxy::mailbox() const { return m_mailbox; }
 167 int     VoicemailProxy::count() const { return m_count; }
 168 bool    VoicemailProxy::waiting() const { return m_waiting; }
 169
 170 void VoicemailProxy::setMailbox(QString lineid)
 171 {
 172 TRACE
 173     if (lineid.isEmpty() || (m_mailbox == lineid))
 174         return;
 175
 176     QDBusPendingReply<> reply;
 177     reply = SetProperty("VoicemailMailboxNumber", QDBusVariant(lineid));
 178     reply.waitForFinished();
 179
 180     if (reply.isError())
 181         qCritical() << "SetProperty \"VoicemailMailboxNumber\" failed: " <<
 182                        reply.error().message();
 183     else
 184         m_mailbox = lineid;
 185 }
 186
 187 void VoicemailProxy::voicemailDBusGetPropDone(QDBusPendingCallWatcher *call)
 188 {
 189 TRACE
 190     QDBusPendingReply<QVariantMap> reply = *call;
 191
 192     if (reply.isError()) {
 193       // TODO: Handle this properly, by setting states, or disabling features...
 194       qDebug() << "org.ofono.MessageWaiting.getProperties() failed: " <<
 195                   reply.error().message();
 196     } else {
 197       QVariantMap properties = reply.value();
 198       bool waiting = qdbus_cast<bool>(properties["VoicemailWaiting"]);
 199       int count = qdbus_cast<int>(properties["VoicemailMessageCount"]);
 200       QString mailbox = qdbus_cast<QString>(properties["VoicemailMailboxNumber"]);
 201
 202       if (count != m_count) {
 203           m_count = count;
 204           emit messagesWaitingChanged();
 205       }
 206       if (waiting != m_waiting) {
 207           m_waiting = waiting;
 208           emit messagesWaitingChanged();
 209       }
 210       if (!mailbox.isEmpty() && (mailbox != m_mailbox)) {
 211           m_mailbox = mailbox;
 212           emit mailboxChanged();
 213       }
 214
 215       // First sucessfull GetProperties == connected
 216       if (!m_connected) {
 217           m_connected = true;
 218           emit connected();
 219       }
 220     }
 221 }
 222
 223 void VoicemailProxy::voicemailPropertyChanged(const QString &in0, const QDBusVariant &in1)
 224 {
 225 TRACE
 226     qDebug() << QString("Property \"%1\" changed...").arg(in0);
 227     bool waiting;
 228     int count;
 229     QString mailbox;
 230     if (in0 == "VoicemailWaiting") {
 231         waiting = qdbus_cast<bool>(in1.variant());
 232     } else if (in0 == "VoicemailMessageCount") {
 233         count = qdbus_cast<int>(in1.variant());
 234     } else if (in0 == "VoicemailMailboxNumber") {
 235         mailbox = qdbus_cast<QString>(in1.variant());
 236     } else
 237         qDebug() << QString("Unexpected property changed...");
 238
 239     if ((count != m_count) || (waiting != m_waiting)) {
 240         m_count = count;
 241         m_waiting = waiting;
 242         emit messagesWaitingChanged();
 243     }
 244     if (!mailbox.isEmpty() && (mailbox != m_mailbox)) {
 245         m_mailbox = mailbox;
 246         emit mailboxChanged();
 247     }
 248 }
 249
 250 /*
 251  * CallVolume Manager implementation
 252  */
 253
 254 VolumeManager::VolumeManager(const QString &objectPath)
 255     : org::ofono::CallVolume(OFONO_SERVICE,
 256                              objectPath,
 257                              QDBusConnection::systemBus())
 258 {
 259 TRACE
 260     if (!isValid()) {
 261         qDebug() << "Failed to connect to Ofono: \n\t" << lastError().message();
 262     } else {
 263         m_path = objectPath;
 264         QDBusPendingReply<QVariantMap> reply;
 265         QDBusPendingCallWatcher * watcher;
 266
 267         reply = GetProperties();
 268         watcher = new QDBusPendingCallWatcher(reply);
 269
 270         connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
 271                 this, SLOT(volumeDBusGetPropDone(QDBusPendingCallWatcher*)));
 272     }
 273 }
 274
 275 VolumeManager::~VolumeManager()
 276 {
 277 TRACE
 278 }
 279
 280 QString VolumeManager::path() const { return m_path; }
 281 int     VolumeManager::speakerVolume() const { return m_speakerVolume; }
 282 int     VolumeManager::micVolume() const { return m_micVolume; }
 283 bool    VolumeManager::muted() const { return m_muted; }
 284 bool    VolumeManager::isConnected() const { return m_connected; }
 285
 286 void VolumeManager::setSpeakerVolume(int volume)
 287 {
 288 TRACE
 289     if (m_speakerVolume == volume)
 290         return;
 291
 292     if ((volume < 0) || (volume > 100)) {
 293         qWarning() << "SpeakerVolume value out of range (0<>100)";
 294         return;
 295     }
 296
 297     QDBusPendingReply<> reply;
 298     reply = SetProperty("SpeakerVolume", QDBusVariant(volume));
 299     reply.waitForFinished();
 300
 301     if (reply.isError())
 302         qCritical() << "SetProperty \"SpeakerVolume\" failed: " <<
 303                        reply.error().message();
 304     else
 305         m_speakerVolume = volume;
 306 }
 307
 308 void VolumeManager::setMicVolume(int volume)
 309 {
 310 TRACE
 311     if (m_micVolume == volume)
 312         return;
 313
 314     if ((volume < 0) || (volume > 100)) {
 315         qWarning() << "MicrophoneVolume value out of range (0<>100)";
 316         return;
 317     }
 318
 319     QDBusPendingReply<> reply;
 320     reply = SetProperty("MicrophoneVolume", QDBusVariant(volume));
 321     reply.waitForFinished();
 322
 323     if (reply.isError())
 324         qCritical() << "SetProperty \"MicrophoneVolume\" failed: " <<
 325                        reply.error().message();
 326     else
 327         m_micVolume = volume;
 328 }
 329
 330 void VolumeManager::setMuted(bool is_muted)
 331 {
 332 TRACE
 333     if (m_muted == is_muted)
 334         return;
 335
 336     QDBusPendingReply<> reply;
 337     reply = SetProperty("Muted", QDBusVariant(is_muted));
 338     reply.waitForFinished();
 339
 340     if (reply.isError())
 341         qCritical() << "SetProperty \"Muted\" failed: " <<
 342                        reply.error().message();
 343     else
 344         m_muted = is_muted;
 345 }
 346
 347 void VolumeManager::volumeDBusGetPropDone(QDBusPendingCallWatcher *call)
 348 {
 349 TRACE
 350     QDBusPendingReply<QVariantMap> reply = *call;
 351
 352     if (reply.isError()) {
 353       // TODO: Handle this properly, by setting states, or disabling features...
 354       qDebug() << "org.ofono.CallVolume.getProperties() failed: " <<
 355                   reply.error().message();
 356     } else {
 357       QVariantMap properties = reply.value();
 358       m_speakerVolume = qdbus_cast<int>(properties["SpeakerVolume"]);
 359       m_micVolume = qdbus_cast<int>(properties["MicrophoneVolume"]);
 360       m_muted = qdbus_cast<bool>(properties["Muted"]);
 361
 362       // First sucessfull GetProperties == connected
 363       if (!m_connected) {
 364           m_connected = true;
 365           emit connected();
 366       }
 367     }
 368 }