workspace/libs/solid/control/bluetoothmanager.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2006 Will Stephenson <wstephenson@kde.org>
   3     Copyright (C) 2006 Kévin Ottens <ervin@kde.org>
   4     Copyright (C) 2007 Daniel Gollub <dgollub@suse.de>
   5     Copyright (C) 2008 Tom Patzig <tpatzig@suse.de>
   6
   7
   8     This library is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU Library General Public
  10     License version 2 as published by the Free Software Foundation.
  11
  12     This library is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Library General Public License for more details.
  16
  17     You should have received a copy of the GNU Library General Public License
  18     along with this library; see the file COPYING.LIB.  If not, write to
  19     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20     Boston, MA 02110-1301, USA.
  21
  22 */
  23
  24 #include <QMap>
  25 #include <QPair>
  26 #include <QStringList>
  27
  28 #include "ifaces/bluetoothmanager.h"
  29 #include "ifaces/bluetoothinterface.h"
  30 #include "ifaces/bluetoothinputdevice.h"
  31 #include "ifaces/bluetoothsecurity.h"
  32
  33 #include "soliddefs_p.h"
  34 #include "managerbase_p.h"
  35
  36 #include "bluetoothinterface.h"
  37 #include "bluetoothmanager.h"
  38 #include "bluetoothsecurity.h"
  39
  40 #include <kdebug.h>
  41
  42 namespace Solid
  43 {
  44 namespace Control
  45 {
  46 class BluetoothManagerPrivate : public ManagerBasePrivate
  47 {
  48 public:
  49     BluetoothManagerPrivate(BluetoothManager *parent)
  50         : q(parent) { }
  51
  52     BluetoothManager * const q;
  53
  54     QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> findRegisteredBluetoothInterface(const QString &ubi) const;
  55     QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> findRegisteredBluetoothInputDevice(const QString &ubi) const;
  56
  57     void connectBackend(QObject *newBackend);
  58
  59     void _k_interfaceAdded(const QString &ubi);
  60     void _k_interfaceRemoved(const QString &ubi);
  61     void _k_defaultInterfaceChanged(const QString &ubi);
  62     void _k_interfaceDestroyed(QObject *object);
  63 /*
  64     void _k_inputDeviceCreated(const QString &ubi);
  65     void _k_inputDeviceRemoved(const QString &ubi);
  66     void _k_inputDeviceDestroyed(QObject *object);
  67 */
  68
  69     mutable QMap<QString, QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> > bluetoothInterfaceMap;
  70     mutable QMap<QString, QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> > bluetoothInputDeviceMap;
  71
  72     BluetoothInterface invalidInterface;
  73     BluetoothInputDevice invalidInputDevice;
  74 };
  75 }
  76 }
  77
  78 SOLID_SINGLETON_IMPLEMENTATION(Solid::Control::BluetoothManager, BluetoothManager)
  79
  80
  81 Solid::Control::BluetoothManager::BluetoothManager()
  82         : QObject(), d(new BluetoothManagerPrivate(this))
  83 {
  84     d->loadBackend("Bluetooth Management",
  85                    "SolidBluetoothManager",
  86                    "Solid::Control::Ifaces::BluetoothManager");
  87
  88     if (d->managerBackend() != 0) {
  89         d->connectBackend(d->managerBackend());
  90     }
  91 }
  92
  93 Solid::Control::BluetoothManager::~BluetoothManager()
  94 {
  95     // Delete all the interfaces, they are now outdated
  96     typedef QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> BluetoothInterfaceIfacePair;
  97
  98     // Delete all the devices, they are now outdated
  99     foreach (const BluetoothInterfaceIfacePair &pair, d->bluetoothInterfaceMap.values()) {
 100         delete pair.first;
 101         delete pair.second;
 102     }
 103
 104     d->bluetoothInterfaceMap.clear();
 105 }
 106
 107 Solid::Control::BluetoothInterfaceList Solid::Control::BluetoothManager::buildDeviceList(const QStringList  & ubiList) const
 108 {
 109     BluetoothInterfaceList list;
 110     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 111
 112     if (backend == 0) return list;
 113
 114     kDebug() << "UBI List " << ubiList;
 115
 116     foreach (const QString &ubi, ubiList) {
 117         QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = d->findRegisteredBluetoothInterface(ubi);
 118
 119         if (pair.first != 0) {
 120             list.append(*pair.first);
 121         }
 122     }
 123
 124     return list;
 125 }
 126
 127
 128 Solid::Control::BluetoothInterfaceList Solid::Control::BluetoothManager::bluetoothInterfaces() const
 129 {
 130     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 131
 132     if (backend != 0) {
 133         return buildDeviceList(backend->bluetoothInterfaces());
 134     } else {
 135         return BluetoothInterfaceList();
 136     }
 137 }
 138 /*
 139 QStringList Solid::Control::BluetoothManager::bluetoothInterfaces() const
 140 {
 141     return_SOLID_CALL(Ifaces::BluetoothManager *, d->managerBackend(), QStringList(), bluetoothInterfaces());
 142 }
 143 */
 144 QString Solid::Control::BluetoothManager::defaultInterface() const
 145 {
 146     return_SOLID_CALL(Ifaces::BluetoothManager *, d->managerBackend(), QString(), defaultInterface());
 147 }
 148
 149 Solid::Control::BluetoothInterface Solid::Control::BluetoothManager::findBluetoothInterface(const QString &ubi) const
 150 {
 151     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 152
 153     if (backend == 0) return d->invalidInterface;
 154
 155     QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = d->findRegisteredBluetoothInterface(ubi);
 156
 157     if (pair.first != 0) {
 158         return *pair.first;
 159     } else {
 160         return d->invalidInterface;
 161     }
 162 }
 163
 164 QString Solid::Control::BluetoothManager::findInterface(const QString &dev) const
 165 {
 166     return_SOLID_CALL(Ifaces::BluetoothManager *, d->managerBackend(), QString(), findInterface(dev));
 167 }
 168
 169 /*
 170 Solid::Control::BluetoothInputDevice Solid::Control::BluetoothManager::findBluetoothInputDevice(const QString &ubi) const
 171 {
 172     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 173
 174     if (backend == 0) return d->invalidInputDevice;
 175
 176     QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = d->findRegisteredBluetoothInputDevice(ubi);
 177
 178     if (pair.first != 0) {
 179         return *pair.first;
 180     } else {
 181         return d->invalidInputDevice;
 182     }
 183 }
 184 */
 185
 186 /*
 187 Solid::Control::BluetoothInputDevice* Solid::Control::BluetoothManager::createBluetoothInputDevice(const QString &ubi)
 188 {
 189         Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 190         Ifaces::BluetoothInputDevice *iface = 0;
 191         if (backend != 0) {
 192             iface = qobject_cast<Ifaces::BluetoothInputDevice *>(backend->createBluetoothInputDevice(ubi));
 193         }
 194         if (iface != 0) {
 195             BluetoothInputDevice *device = new BluetoothInputDevice(iface);
 196             return device;
 197
 198         } else {
 199             return &d->invalidInputDevice;
 200         }
 201
 202 }
 203
 204 KJob *Solid::Control::BluetoothManager::setupInputDevice(const QString &ubi)
 205 {
 206     return_SOLID_CALL(Ifaces::BluetoothManager *, d->managerBackend(), 0, setupInputDevice(ubi));
 207 }
 208
 209 Solid::Control::BluetoothInputDeviceList Solid::Control::BluetoothManager::bluetoothInputDevices() const
 210 {
 211     BluetoothInputDeviceList list;
 212     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(d->managerBackend());
 213
 214     if (backend == 0) return list;
 215
 216     QStringList ubis = backend->bluetoothInputDevices();
 217
 218     foreach (const QString &ubi, ubis) {
 219         QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = d->findRegisteredBluetoothInputDevice(ubi);
 220
 221         if (pair.first != 0) {
 222             list.append(*pair.first);
 223         }
 224     }
 225     return list;
 226 }
 227
 228 Solid::Control::BluetoothSecurity *Solid::Control::BluetoothManager::security(const QString &interface)
 229 {
 230     Ifaces::BluetoothManager *backendManager = qobject_cast<Ifaces::BluetoothManager*>(d->managerBackend());
 231     if (backendManager!=0) {
 232         Ifaces::BluetoothSecurity *backendSecurity = backendManager->security(interface);
 233         return new Solid::Control::BluetoothSecurity(backendSecurity);
 234     }
 235     return 0;
 236 }
 237
 238 void Solid::Control::BluetoothManager::removeInputDevice(const QString &ubi)
 239 {
 240     SOLID_CALL(Ifaces::BluetoothManager *, d->managerBackend(), removeInputDevice(ubi));
 241 }
 242 */
 243 void Solid::Control::BluetoothManagerPrivate::_k_interfaceAdded(const QString &ubi)
 244 {
 245     kDebug() << "Size of InterfaceList " << bluetoothInterfaceMap.size();
 246     QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = findRegisteredBluetoothInterface(ubi);
 247 /*    QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = bluetoothInterfaceMap.take(ubi);
 248
 249     if (pair.first != 0) {
 250         // Oops, I'm not sure it should happen...
 251         // But well in this case we'd better kill the old device we got, it's probably outdated
 252
 253         delete pair.first;
 254         delete pair.second;
 255     }*/
 256
 257     emit q->interfaceAdded(ubi);
 258 }
 259
 260 void Solid::Control::BluetoothManagerPrivate::_k_interfaceRemoved(const QString &ubi)
 261 {
 262     QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = bluetoothInterfaceMap.take(ubi);
 263
 264     if (pair.first != 0) {
 265         delete pair.first;
 266         delete pair.second;
 267     }
 268
 269     Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(managerBackend());
 270     backend->removeInterface(ubi);
 271     emit q->interfaceRemoved(ubi);
 272 }
 273
 274 void Solid::Control::BluetoothManagerPrivate::_k_defaultInterfaceChanged(const QString &ubi)
 275 {
 276     emit q->defaultInterfaceChanged(ubi);
 277 }
 278
 279 void Solid::Control::BluetoothManagerPrivate::_k_interfaceDestroyed(QObject *object)
 280 {
 281     kDebug() << "Interface detroyed";
 282     Ifaces::BluetoothInterface *device = qobject_cast<Ifaces::BluetoothInterface *>(object);
 283
 284     if (device != 0) {
 285         QString ubi = device->ubi();
 286         QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = bluetoothInterfaceMap.take(ubi);
 287         delete pair.first;
 288     }
 289 }
 290
 291 /*
 292 void Solid::Control::BluetoothManagerPrivate::_k_inputDeviceCreated(const QString &ubi)
 293 {
 294     QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = bluetoothInputDeviceMap.take(ubi);
 295
 296     if (pair.first != 0) {
 297         // Oops, I'm not sure it should happen...
 298         // But well in this case we'd better kill the old device we got, it's probably outdated
 299
 300         delete pair.first;
 301         delete pair.second;
 302     }
 303
 304     emit q->inputDeviceCreated(ubi);
 305 }
 306
 307 void Solid::Control::BluetoothManagerPrivate::_k_inputDeviceRemoved(const QString &ubi)
 308 {
 309     QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = bluetoothInputDeviceMap.take(ubi);
 310
 311     if (pair.first != 0) {
 312         delete pair.first;
 313         delete pair.second;
 314     }
 315
 316     emit q->inputDeviceRemoved(ubi);
 317 }
 318
 319 void Solid::Control::BluetoothManagerPrivate::_k_inputDeviceDestroyed(QObject *object)
 320 {
 321     Ifaces::BluetoothInputDevice *device = qobject_cast<Ifaces::BluetoothInputDevice *>(object);
 322
 323     if (device != 0) {
 324         QString ubi = device->ubi();
 325         QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = bluetoothInputDeviceMap.take(ubi);
 326         delete pair.first;
 327     }
 328 }
 329 */
 330
 331 /***************************************************************************/
 332
 333 void Solid::Control::BluetoothManagerPrivate::connectBackend(QObject *newBackend)
 334 {
 335     QObject::connect(newBackend, SIGNAL(interfaceAdded(const QString &)),
 336                      q, SLOT(_k_interfaceAdded(const QString &)));
 337     QObject::connect(newBackend, SIGNAL(interfaceRemoved(const QString &)),
 338                      q, SLOT(_k_interfaceRemoved(const QString &)));
 339     QObject::connect(newBackend, SIGNAL(defaultInterfaceChanged(const QString &)),
 340                      q, SLOT(_k_defaultInterfaceChanged(const QString &)));
 341
 342 /*
 343     QObject::connect(newBackend, SIGNAL(inputDeviceCreated(const QString &)),
 344                      q, SLOT(_k_inputDeviceCreated(const QString &)));
 345     QObject::connect(newBackend, SIGNAL(inputDeviceRemoved(const QString &)),
 346                      q, SLOT(_k_inputDeviceRemoved(const QString &)));
 347 */
 348
 349 }
 350
 351 QPair<Solid::Control::BluetoothInterface *, Solid::Control::Ifaces::BluetoothInterface *> Solid::Control::BluetoothManagerPrivate::findRegisteredBluetoothInterface(const QString &ubi) const
 352 {
 353
 354     kDebug() << "findRegisteredBluetoothInterface " << ubi;
 355     if (bluetoothInterfaceMap.contains(ubi)) {
 356         return bluetoothInterfaceMap[ubi];
 357     } else {
 358         kDebug() << "Creating New Interface " << ubi;
 359         Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(managerBackend());
 360         Ifaces::BluetoothInterface *iface = 0;
 361
 362         if (backend != 0) {
 363             kDebug() << "Calling Backend to Creating New Interface " << ubi;
 364             iface = qobject_cast<Ifaces::BluetoothInterface *>(backend->createInterface(ubi));
 365         }
 366
 367         if (iface != 0) {
 368             kDebug() << "BackendIface created ";
 369             BluetoothInterface *device = new BluetoothInterface(iface);
 370             QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair(device, iface);
 371             QObject::connect(iface, SIGNAL(destroyed(QObject *)),
 372                              q, SLOT(_k_interfaceDestroyed(QObject *)));
 373             bluetoothInterfaceMap[ubi] = pair;
 374             return pair;
 375         } else {
 376             return QPair<BluetoothInterface *, Ifaces::BluetoothInterface *>(0, 0);
 377         }
 378     }
 379 }
 380
 381 /*
 382 QPair<Solid::Control::BluetoothInputDevice *, Solid::Control::Ifaces::BluetoothInputDevice *> Solid::Control::BluetoothManagerPrivate::findRegisteredBluetoothInputDevice(const QString &ubi) const
 383 {
 384
 385     if (bluetoothInputDeviceMap.contains(ubi)) {
 386         return bluetoothInputDeviceMap[ubi];
 387     } else {
 388         Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(managerBackend());
 389         Ifaces::BluetoothInputDevice *iface = 0;
 390
 391         if (backend != 0) {
 392             iface = qobject_cast<Ifaces::BluetoothInputDevice *>(backend->createBluetoothInputDevice(ubi));
 393         }
 394
 395         if (iface != 0) {
 396             BluetoothInputDevice *device = new BluetoothInputDevice(iface);
 397             QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair(device, iface);
 398             bluetoothInputDeviceMap[ubi] = pair;
 399             QObject::connect(iface, SIGNAL(destroyed(QObject *)),
 400                              q, SLOT(_k_inputDeviceDestroyed(QObject *)));
 401             return pair;
 402         } else {
 403             return QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *>(0, 0);
 404         }
 405     }
 406 }
 407 */
 408
 409
 410
 411
 412 #include "bluetoothmanager.moc"