workspace/libs/solid/control/bluetoothremotedevice.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2006 Will Stephenson <wstephenson@kde.org>
   3     Copyright (C) 2007 Daniel Gollub <dgollub@suse.de>
   4     Copyright (C) 2008 Tom Patzig <tpatzig@suse.de>
   5
   6
   7     This library is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Library General Public
   9     License version 2 as published by the Free Software Foundation.
  10
  11     This library is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Library General Public License for more details.
  15
  16     You should have received a copy of the GNU Library General Public License
  17     along with this library; see the file COPYING.LIB.  If not, write to
  18     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19     Boston, MA 02110-1301, USA.
  20
  21 */
  22
  23 #include <QMap>
  24 #include <QStringList>
  25
  26 #include "ifaces/bluetoothremotedevice.h"
  27
  28 #include "frontendobject_p.h"
  29
  30 #include "soliddefs_p.h"
  31 #include "bluetoothmanager.h"
  32 #include "bluetoothinterface.h"
  33
  34 namespace Solid
  35 {
  36 namespace Control
  37 {
  38     class BluetoothRemoteDevicePrivate : public FrontendObjectPrivate
  39     {
  40     public:
  41         BluetoothRemoteDevicePrivate(QObject *parent)
  42             : FrontendObjectPrivate(parent) { }
  43
  44         void setBackendObject(QObject *object);
  45     };
  46 }
  47 }
  48
  49 Solid::Control::BluetoothRemoteDevice::BluetoothRemoteDevice(QObject *backendObject)
  50     : QObject(), d_ptr(new BluetoothRemoteDevicePrivate(this))
  51 {
  52     Q_D(BluetoothRemoteDevice);
  53     d->setBackendObject(backendObject);
  54 }
  55
  56 Solid::Control::BluetoothRemoteDevice::BluetoothRemoteDevice(const BluetoothRemoteDevice &device)
  57     : QObject(), d_ptr(new BluetoothRemoteDevicePrivate(this))
  58 {
  59     Q_D(BluetoothRemoteDevice);
  60     d->setBackendObject(device.d_ptr->backendObject());
  61 }
  62
  63 Solid::Control::BluetoothRemoteDevice::~BluetoothRemoteDevice()
  64 {}
  65
  66 Solid::Control::BluetoothRemoteDevice &Solid::Control::BluetoothRemoteDevice::operator=(const Solid::Control::BluetoothRemoteDevice  & dev)
  67 {
  68     Q_D(BluetoothRemoteDevice);
  69     d->setBackendObject(dev.d_ptr->backendObject());
  70
  71     return *this;
  72 }
  73
  74 bool Solid::Control::BluetoothRemoteDevice::operator==(const BluetoothRemoteDevice  & other) const
  75 {
  76         return ubi() == other.ubi();
  77 }
  78
  79 QString Solid::Control::BluetoothRemoteDevice::ubi() const
  80 {
  81     Q_D(const BluetoothRemoteDevice);
  82     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), ubi());
  83 }
  84
  85 QMap<QString,QVariant> Solid::Control::BluetoothRemoteDevice::getProperties()
  86 {
  87     Q_D(const BluetoothRemoteDevice);
  88     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), (QMap< QString,QVariant >()), getProperties());
  89 }
  90
  91 QVariant Solid::Control::BluetoothRemoteDevice::getProperty(const QString &key)
  92 {
  93     QMap<QString, QVariant> props = getProperties();
  94     if (props.contains(key))
  95         return props[key];
  96     else
  97         return QVariant();
  98 }
  99
 100 QStringList Solid::Control::BluetoothRemoteDevice::listNodes()
 101 {
 102     Q_D(const BluetoothRemoteDevice);
 103     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QStringList(), listNodes());
 104 }
 105
 106 void Solid::Control::BluetoothRemoteDevice::setProperty(const QString &name, const QVariant &value)
 107 {
 108     Q_D(const BluetoothRemoteDevice);
 109     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), setProperty(name,value));
 110 }
 111
 112 void Solid::Control::BluetoothRemoteDevice::cancelDiscovery()
 113 {
 114     Q_D(const BluetoothRemoteDevice);
 115     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), cancelDiscovery());
 116 }
 117
 118 void Solid::Control::BluetoothRemoteDevice::disconnect()
 119 {
 120     Q_D(const BluetoothRemoteDevice);
 121     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), disconnect());
 122 }
 123
 124
 125 QString Solid::Control::BluetoothRemoteDevice::address()
 126 {
 127     QVariant var = getProperty("Address");
 128
 129     if (var.isValid())
 130         return var.value<QString>();
 131     else
 132         return QString();
 133
 134 //    Q_D(const BluetoothRemoteDevice);
 135 //    return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), address());
 136 }
 137
 138 bool Solid::Control::BluetoothRemoteDevice::isTrusted()
 139 {
 140      QVariant var = getProperty("Trusted");
 141
 142     if (var.isValid())
 143         return var.value<bool>();
 144     else
 145         return false;
 146 }
 147
 148 void Solid::Control::BluetoothRemoteDevice::setTrusted(bool trust)
 149 {
 150     setProperty("Trusted",QVariant(trust));
 151 }
 152
 153 QString Solid::Control::BluetoothRemoteDevice::icon()
 154 {
 155      QVariant var = getProperty("Icon");
 156
 157     if (var.isValid())
 158         return var.value<QString>();
 159     else
 160         return "";
 161 }
 162
 163 QStringList Solid::Control::BluetoothRemoteDevice::uuids()
 164 {
 165      QVariant var = getProperty("UUIDs");
 166
 167     if (var.isValid())
 168         return var.value<QStringList>();
 169     else
 170         return QStringList();
 171 }
 172
 173 bool Solid::Control::BluetoothRemoteDevice::isConnected()
 174 {
 175      QVariant var = getProperty("Connected");
 176
 177     if (var.isValid())
 178         return var.value<bool>();
 179     else
 180         return false;
 181 }
 182
 183 /*
 184 bool Solid::Control::BluetoothRemoteDevice::isConnected() const
 185 {
 186     Q_D(const BluetoothRemoteDevice);
 187     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), false, isConnected());
 188 }
 189
 190 QString Solid::Control::BluetoothRemoteDevice::version() const
 191 {
 192     Q_D(const BluetoothRemoteDevice);
 193     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), version());
 194 }
 195
 196 QString Solid::Control::BluetoothRemoteDevice::revision() const
 197 {
 198     Q_D(const BluetoothRemoteDevice);
 199     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), revision());
 200 }
 201
 202 QString Solid::Control::BluetoothRemoteDevice::manufacturer() const
 203 {
 204     Q_D(const BluetoothRemoteDevice);
 205     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), manufacturer());
 206 }
 207
 208 QString Solid::Control::BluetoothRemoteDevice::company() const
 209 {
 210     Q_D(const BluetoothRemoteDevice);
 211     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), company());
 212 }
 213
 214 QString Solid::Control::BluetoothRemoteDevice::majorClass() const
 215 {
 216     Q_D(const BluetoothRemoteDevice);
 217     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), majorClass());
 218 }
 219
 220 QString Solid::Control::BluetoothRemoteDevice::minorClass() const
 221 {
 222     Q_D(const BluetoothRemoteDevice);
 223     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), minorClass());
 224 }
 225
 226 QStringList Solid::Control::BluetoothRemoteDevice::serviceClasses() const
 227 {
 228     Q_D(const BluetoothRemoteDevice);
 229     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QStringList(), serviceClasses());
 230 }
 231 */
 232
 233 QString Solid::Control::BluetoothRemoteDevice::name()
 234 {
 235     QVariant var = getProperty("Name");
 236
 237     if (var.isValid())
 238         return var.value<QString>();
 239     else
 240         return QString();
 241
 242 //    return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), name());
 243 }
 244
 245 /*
 246 QString Solid::Control::BluetoothRemoteDevice::alias() const
 247 {
 248     Q_D(const BluetoothRemoteDevice);
 249     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), alias());
 250 }
 251
 252 QString Solid::Control::BluetoothRemoteDevice::lastSeen() const
 253 {
 254     Q_D(const BluetoothRemoteDevice);
 255     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), lastSeen());
 256 }
 257
 258 QString Solid::Control::BluetoothRemoteDevice::lastUsed() const
 259 {
 260     Q_D(const BluetoothRemoteDevice);
 261     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), lastUsed());
 262 }
 263
 264 bool Solid::Control::BluetoothRemoteDevice::hasBonding() const
 265 {
 266     Q_D(const BluetoothRemoteDevice);
 267     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), false, hasBonding());
 268 }
 269
 270 int Solid::Control::BluetoothRemoteDevice::pinCodeLength() const
 271 {
 272     Q_D(const BluetoothRemoteDevice);
 273     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, pinCodeLength());
 274 }
 275
 276 int Solid::Control::BluetoothRemoteDevice::encryptionKeySize() const
 277 {
 278     Q_D(const BluetoothRemoteDevice);
 279     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, encryptionKeySize());
 280 }
 281
 282 KJob *Solid::Control::BluetoothRemoteDevice::createBonding()
 283 {
 284     Q_D(BluetoothRemoteDevice);
 285     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, createBonding());
 286 }
 287
 288 void Solid::Control::BluetoothRemoteDevice::setAlias(const QString &alias)
 289 {
 290     Q_D(BluetoothRemoteDevice);
 291     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), setAlias(alias));
 292 }
 293
 294 void Solid::Control::BluetoothRemoteDevice::clearAlias()
 295 {
 296     Q_D(BluetoothRemoteDevice);
 297     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), clearAlias());
 298 }
 299
 300 void Solid::Control::BluetoothRemoteDevice::disconnect()
 301 {
 302     Q_D(BluetoothRemoteDevice);
 303     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), disconnect());
 304 }
 305
 306 void Solid::Control::BluetoothRemoteDevice::cancelBondingProcess()
 307 {
 308     Q_D(BluetoothRemoteDevice);
 309     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), cancelBondingProcess());
 310 }
 311
 312 void Solid::Control::BluetoothRemoteDevice::removeBonding()
 313 {
 314     Q_D(const BluetoothRemoteDevice);
 315     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), removeBonding());
 316 }
 317 void Solid::Control::BluetoothRemoteDevice::serviceHandles(const QString &filter) const
 318 {
 319     Q_D(const BluetoothRemoteDevice);
 320     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), serviceHandles(filter));
 321 }
 322
 323 void Solid::Control::BluetoothRemoteDevice::serviceRecordAsXml(uint handle) const
 324 {
 325     Q_D(const BluetoothRemoteDevice);
 326     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), serviceRecordAsXml(handle));
 327 }
 328 */
 329
 330 void Solid::Control::BluetoothRemoteDevice::discoverServices(const QString &filter)
 331 {
 332     Q_D(const BluetoothRemoteDevice);
 333     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), discoverServices(filter));
 334 }
 335
 336 void Solid::Control::BluetoothRemoteDevicePrivate::setBackendObject(QObject *object)
 337 {
 338     FrontendObjectPrivate::setBackendObject(object);
 339
 340     if (object) {
 341         /*
 342         QObject::connect(object, SIGNAL(classChanged(uint)),
 343                          parent(), SIGNAL(classChanged(uint)));
 344         QObject::connect(object, SIGNAL(nameChanged(const QString &)),
 345                          parent(), SIGNAL(nameChanged(const QString &)));
 346         QObject::connect(object, SIGNAL(nameResolvingFailed()),
 347                          parent(), SIGNAL(nameResolvingFailed()));
 348         QObject::connect(object, SIGNAL(aliasChanged(const QString &)),
 349                          parent(), SIGNAL(aliasChanged(const QString &)));
 350         QObject::connect(object, SIGNAL(aliasCleared()),
 351                          parent(), SIGNAL(aliasCleared()));
 352         QObject::connect(object, SIGNAL(connected()),
 353                          parent(), SIGNAL(connected()));
 354         QObject::connect(object, SIGNAL(requestDisconnection()),
 355                          parent(), SIGNAL(requestDisconnection()));
 356         QObject::connect(object, SIGNAL(disconnected()),
 357                          parent(), SIGNAL(disconnected()));
 358         QObject::connect(object, SIGNAL(bondingCreated()),
 359                          parent(), SIGNAL(bondingCreated()));
 360         QObject::connect(object, SIGNAL(bondingRemoved()),
 361                          parent(), SIGNAL(bondingRemoved()));
 362         QObject::connect(object, SIGNAL(serviceHandlesAvailable(const QString &, const QList<uint> &)),
 363                          parent(), SIGNAL(serviceHandlesAvailable(const QString &, const QList<uint> &)));
 364         QObject::connect(object, SIGNAL(serviceRecordXmlAvailable(const QString &, const QString &)),
 365                          parent(), SIGNAL(serviceRecordXmlAvailable(const QString &, const QString &)));
 366         */
 367
 368         QObject::connect(object, SIGNAL(serviceDiscoverAvailable(const QString &, const QMap< uint,QString> &)),
 369                          parent(), SIGNAL(serviceDiscoverAvailable(const QString &, const QMap< uint,QString > &)));
 370         QObject::connect(object, SIGNAL(propertyChanged(const QString &, const QVariant &)),
 371                          parent(), SIGNAL(propertyChanged(const QString &, const QVariant &)));
 372         QObject::connect(object, SIGNAL(disconnectRequested()),
 373                          parent(), SIGNAL(disconnectRequested()));
 374         QObject::connect(object, SIGNAL(nodeCreated(const QString &)),
 375                          parent(), SIGNAL(nodeCreated(const QString &)));
 376         QObject::connect(object, SIGNAL(nodeRemoved(const QString &)),
 377                          parent(), SIGNAL(nodeRemoved(const QString &)));
 378
 379
 380
 381     }
 382 }
 383
 384 #include "bluetoothremotedevice.moc"