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
   5
   6     This library is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU Library General Public
   8     License version 2 as published by the Free Software Foundation.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public License
  16     along with this library; see the file COPYING.LIB.  If not, write to
  17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18     Boston, MA 02110-1301, USA.
  19
  20 */
  21
  22 #include <QMap>
  23 #include <QStringList>
  24
  25 #include <solid/control/ifaces/bluetoothremotedevice.h>
  26
  27 #include "frontendobject_p.h"
  28
  29 #include "soliddefs_p.h"
  30 #include "bluetoothmanager.h"
  31 #include "bluetoothinterface.h"
  32
  33 namespace Solid
  34 {
  35 namespace Control
  36 {
  37     class BluetoothRemoteDevicePrivate : public FrontendObjectPrivate
  38     {
  39     public:
  40         BluetoothRemoteDevicePrivate(QObject *parent)
  41             : FrontendObjectPrivate(parent) { }
  42
  43         void setBackendObject(QObject *object);
  44     };
  45 }
  46 }
  47
  48 Solid::Control::BluetoothRemoteDevice::BluetoothRemoteDevice(QObject *backendObject)
  49     : QObject(), d_ptr(new BluetoothRemoteDevicePrivate(this))
  50 {
  51     Q_D(BluetoothRemoteDevice);
  52     d->setBackendObject(backendObject);
  53 }
  54
  55 Solid::Control::BluetoothRemoteDevice::BluetoothRemoteDevice(const BluetoothRemoteDevice &device)
  56     : QObject(), d_ptr(new BluetoothRemoteDevicePrivate(this))
  57 {
  58     Q_D(BluetoothRemoteDevice);
  59     d->setBackendObject(device.d_ptr->backendObject());
  60 }
  61
  62 Solid::Control::BluetoothRemoteDevice::~BluetoothRemoteDevice()
  63 {}
  64
  65 Solid::Control::BluetoothRemoteDevice &Solid::Control::BluetoothRemoteDevice::operator=(const Solid::Control::BluetoothRemoteDevice  & dev)
  66 {
  67     Q_D(BluetoothRemoteDevice);
  68     d->setBackendObject(dev.d_ptr->backendObject());
  69
  70     return *this;
  71 }
  72
  73 bool Solid::Control::BluetoothRemoteDevice::operator==(const BluetoothRemoteDevice  & other) const
  74 {
  75         return ubi() == other.ubi();
  76 }
  77
  78 QString Solid::Control::BluetoothRemoteDevice::ubi() const
  79 {
  80     Q_D(const BluetoothRemoteDevice);
  81     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), ubi());
  82 }
  83
  84 QString Solid::Control::BluetoothRemoteDevice::address() const
  85 {
  86     Q_D(const BluetoothRemoteDevice);
  87     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), address());
  88 }
  89
  90 bool Solid::Control::BluetoothRemoteDevice::isConnected() const
  91 {
  92     Q_D(const BluetoothRemoteDevice);
  93     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), false, isConnected());
  94 }
  95
  96 QString Solid::Control::BluetoothRemoteDevice::version() const
  97 {
  98     Q_D(const BluetoothRemoteDevice);
  99     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), version());
 100 }
 101
 102 QString Solid::Control::BluetoothRemoteDevice::revision() const
 103 {
 104     Q_D(const BluetoothRemoteDevice);
 105     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), revision());
 106 }
 107
 108 QString Solid::Control::BluetoothRemoteDevice::manufacturer() const
 109 {
 110     Q_D(const BluetoothRemoteDevice);
 111     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), manufacturer());
 112 }
 113
 114 QString Solid::Control::BluetoothRemoteDevice::company() const
 115 {
 116     Q_D(const BluetoothRemoteDevice);
 117     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), company());
 118 }
 119
 120 QString Solid::Control::BluetoothRemoteDevice::majorClass() const
 121 {
 122     Q_D(const BluetoothRemoteDevice);
 123     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), majorClass());
 124 }
 125
 126 QString Solid::Control::BluetoothRemoteDevice::minorClass() const
 127 {
 128     Q_D(const BluetoothRemoteDevice);
 129     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), minorClass());
 130 }
 131
 132 QStringList Solid::Control::BluetoothRemoteDevice::serviceClasses() const
 133 {
 134     Q_D(const BluetoothRemoteDevice);
 135     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QStringList(), serviceClasses());
 136 }
 137 QString Solid::Control::BluetoothRemoteDevice::name() const
 138 {
 139     Q_D(const BluetoothRemoteDevice);
 140     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), name());
 141 }
 142
 143 QString Solid::Control::BluetoothRemoteDevice::alias() const
 144 {
 145     Q_D(const BluetoothRemoteDevice);
 146     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), alias());
 147 }
 148
 149 QString Solid::Control::BluetoothRemoteDevice::lastSeen() const
 150 {
 151     Q_D(const BluetoothRemoteDevice);
 152     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), lastSeen());
 153 }
 154
 155 QString Solid::Control::BluetoothRemoteDevice::lastUsed() const
 156 {
 157     Q_D(const BluetoothRemoteDevice);
 158     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), lastUsed());
 159 }
 160
 161 bool Solid::Control::BluetoothRemoteDevice::hasBonding() const
 162 {
 163     Q_D(const BluetoothRemoteDevice);
 164     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), false, hasBonding());
 165 }
 166
 167 int Solid::Control::BluetoothRemoteDevice::pinCodeLength() const
 168 {
 169     Q_D(const BluetoothRemoteDevice);
 170     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, pinCodeLength());
 171 }
 172
 173 int Solid::Control::BluetoothRemoteDevice::encryptionKeySize() const
 174 {
 175     Q_D(const BluetoothRemoteDevice);
 176     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, encryptionKeySize());
 177 }
 178
 179 KJob *Solid::Control::BluetoothRemoteDevice::createBonding()
 180 {
 181     Q_D(BluetoothRemoteDevice);
 182     return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), 0, createBonding());
 183 }
 184
 185 void Solid::Control::BluetoothRemoteDevice::setAlias(const QString &alias)
 186 {
 187     Q_D(BluetoothRemoteDevice);
 188     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), setAlias(alias));
 189 }
 190
 191 void Solid::Control::BluetoothRemoteDevice::clearAlias()
 192 {
 193     Q_D(BluetoothRemoteDevice);
 194     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), clearAlias());
 195 }
 196
 197 void Solid::Control::BluetoothRemoteDevice::disconnect()
 198 {
 199     Q_D(BluetoothRemoteDevice);
 200     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), disconnect());
 201 }
 202
 203 void Solid::Control::BluetoothRemoteDevice::cancelBondingProcess()
 204 {
 205     Q_D(BluetoothRemoteDevice);
 206     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), cancelBondingProcess());
 207 }
 208
 209 void Solid::Control::BluetoothRemoteDevice::removeBonding()
 210 {
 211     Q_D(const BluetoothRemoteDevice);
 212     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), removeBonding());
 213 }
 214 void Solid::Control::BluetoothRemoteDevice::serviceHandles(const QString &filter) const
 215 {
 216     Q_D(const BluetoothRemoteDevice);
 217     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), serviceHandles(filter));
 218 }
 219
 220 void Solid::Control::BluetoothRemoteDevice::serviceRecordAsXml(uint handle) const
 221 {
 222     Q_D(const BluetoothRemoteDevice);
 223     SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), serviceRecordAsXml(handle));
 224 }
 225
 226 void Solid::Control::BluetoothRemoteDevicePrivate::setBackendObject(QObject *object)
 227 {
 228     FrontendObjectPrivate::setBackendObject(object);
 229
 230     if (object) {
 231         QObject::connect(object, SIGNAL(classChanged(uint)),
 232                          parent(), SIGNAL(classChanged(uint)));
 233         QObject::connect(object, SIGNAL(nameChanged(const QString &)),
 234                          parent(), SIGNAL(nameChanged(const QString &)));
 235         QObject::connect(object, SIGNAL(nameResolvingFailed()),
 236                          parent(), SIGNAL(nameResolvingFailed()));
 237         QObject::connect(object, SIGNAL(aliasChanged(const QString &)),
 238                          parent(), SIGNAL(aliasChanged(const QString &)));
 239         QObject::connect(object, SIGNAL(aliasCleared()),
 240                          parent(), SIGNAL(aliasCleared()));
 241         QObject::connect(object, SIGNAL(connected()),
 242                          parent(), SIGNAL(connected()));
 243         QObject::connect(object, SIGNAL(requestDisconnection()),
 244                          parent(), SIGNAL(requestDisconnection()));
 245         QObject::connect(object, SIGNAL(disconnected()),
 246                          parent(), SIGNAL(disconnected()));
 247         QObject::connect(object, SIGNAL(bondingCreated()),
 248                          parent(), SIGNAL(bondingCreated()));
 249         QObject::connect(object, SIGNAL(bondingRemoved()),
 250                          parent(), SIGNAL(bondingRemoved()));
 251         QObject::connect(object, SIGNAL(serviceHandlesAvailable(const QString &, const QList<uint> &)),
 252                          parent(), SIGNAL(serviceHandlesAvailable(const QString &, const QList<uint> &)));
 253         QObject::connect(object, SIGNAL(serviceRecordXmlAvailable(const QString &, const QString &)),
 254                          parent(), SIGNAL(serviceRecordXmlAvailable(const QString &, const QString &)));
 255
 256     }
 257 }
 258
 259 #include "bluetoothremotedevice.moc"