workspace/solid/bluez/bluez-bluetoothremotedevice.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2007 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 "bluez-bluetoothremotedevice.h"
  24
  25 #include <QQueue>
  26 #include <QTimer>
  27
  28 #include <kdebug.h>
  29
  30 #include <solid/control/bluetoothremotedevice.h>
  31
  32 #include "bluezcalljob.h"
  33
  34 Q_DECLARE_METATYPE(QList<uint>)
  35
  36 BluezBluetoothRemoteDevice::BluezBluetoothRemoteDevice(const QString &objectPath)
  37         : BluetoothRemoteDevice(0), m_objectPath(objectPath)
  38 {
  39
  40     // size("/FF:FF:FF:FF:FF:FF") == 18
  41         //Q_ASSERT(objectPath.startsWith('/'));
  42         m_adapter = m_objectPath.left(objectPath.size() - 18);
  43         m_address = m_objectPath.right(17);
  44
  45         kdDebug() << "Connecting to ObjectPath: " << objectPath;
  46
  47         device = new QDBusInterface("org.bluez", objectPath,
  48                                     "org.bluez.Device", QDBusConnection::systemBus());
  49         #define connectDeviceToThis(signal, slot) \
  50                 device->connection().connect("org.bluez", \
  51                         objectPath, \
  52                         "org.bluez.Device", \
  53                         signal, this, SLOT(slot))
  54         connectDeviceToThis("PropertyChanged",slotPropertyChanged(const QString &,const QDBusVariant &));
  55         connectDeviceToThis("DisconnectRequested",slotDisconnectRequested());
  56         connectDeviceToThis("NodeCreated",slotNodeCreated(const QDBusObjectPath &));
  57         connectDeviceToThis("NodeRemoved",slotNodeRemoved(const QDBusObjectPath &));
  58
  59
  60 }
  61
  62 BluezBluetoothRemoteDevice::~BluezBluetoothRemoteDevice()
  63 {
  64         delete device;
  65 }
  66
  67 QString BluezBluetoothRemoteDevice::ubi() const
  68 {
  69     return device->path();
  70 }
  71
  72 QMap<QString,QVariant> BluezBluetoothRemoteDevice::getProperties() const
  73 {
  74     QDBusReply< QMap<QString,QVariant> > path = device->call("GetProperties");
  75         if (!path.isValid())
  76             return QMap<QString,QVariant>();
  77
  78         return path.value();
  79 }
  80
  81 void BluezBluetoothRemoteDevice::setProperty(const QString &name, const QVariant &value)
  82 {
  83     device->call("SetProperty",name,qVariantFromValue(QDBusVariant(value)));
  84 }
  85
  86 void BluezBluetoothRemoteDevice::discoverServices(const QString& pattern) const
  87 {
  88     QList<QVariant> args;
  89     args << pattern;
  90     device->callWithCallback("DiscoverServices",
  91             args,
  92             (QObject*)this,
  93             SLOT(slotServiceDiscover(const QMap<uint,QString> &)),
  94             SLOT(dbusErrorServiceDiscover(const QDBusError &)));
  95
  96 }
  97
  98 void BluezBluetoothRemoteDevice::cancelDiscovery()
  99 {
 100     device->call("CancelDiscovery");
 101 }
 102
 103 void BluezBluetoothRemoteDevice::disconnect()
 104 {
 105     device->call("Disconnect");
 106 }
 107
 108 QStringList BluezBluetoothRemoteDevice::listNodes() const
 109 {
 110     QStringList list;
 111     QDBusReply< QList<QDBusObjectPath> > path = device->call("ListNodes");
 112         if (path.isValid()) {
 113             foreach(QDBusObjectPath objectPath, path.value()) {
 114                 list.append(objectPath.path());
 115             }
 116             return list;
 117         }
 118
 119         return QStringList();
 120 }
 121
 122 /*
 123 KJob *BluezBluetoothRemoteDevice::createBonding()
 124 {
 125         QList<QVariant> params;
 126         params << m_address;
 127
 128         return new BluezCallJob(QDBusConnection::systemBus(), "org.bluez", m_adapter,
 129                                 "org.bluez.Adapter", "CreateBonding", params);
 130 }
 131
 132
 133 void BluezBluetoothRemoteDevice::serviceHandles(const QString &filter) const
 134 {
 135         QList<QVariant> args;
 136         args << m_address << filter;
 137         device->callWithCallback("GetRemoteServiceHandles",
 138                                  args,
 139                                  (QObject*)this,
 140                                  SLOT(slotServiceHandles(const QList<uint> &)),
 141                                  SLOT(dbusErrorHandles(const QDBusError &)));
 142
 143 }
 144
 145 void BluezBluetoothRemoteDevice::serviceRecordAsXml(uint handle) const
 146 {
 147         QList<QVariant> args;
 148         args << m_address << handle;
 149         device->callWithCallback("GetRemoteServiceRecordAsXML",
 150                                  args,
 151                                  (QObject*)this,
 152                                  SLOT(slotServiceRecordAsXml(const QString &)),
 153                                  SLOT(dbusErrorRecordAsXml(const QDBusError &)));
 154 }
 155
 156 void BluezBluetoothRemoteDevice::slotServiceRecordAsXml(const QString & record)
 157 {
 158         emit serviceRecordXmlAvailable(ubi(),record);
 159 }
 160 */
 161 void BluezBluetoothRemoteDevice::slotServiceDiscover(const QMap< uint,QString > & handles)
 162 {
 163         emit serviceDiscoverAvailable("success",handles);
 164 }
 165
 166
 167 /******************************/
 168
 169 QStringList BluezBluetoothRemoteDevice::listReply(const QString &method) const
 170 {
 171         QDBusReply< QStringList > reply = device->call(method, m_address);
 172         if (!reply.isValid())
 173                 return QStringList();
 174
 175         return reply.value();
 176 }
 177
 178 QString BluezBluetoothRemoteDevice::stringReply(const QString &method) const
 179 {
 180         QDBusReply< QString > reply = device->call(method, m_address);
 181         if (!reply.isValid())
 182                 return QString();
 183
 184         return reply.value();
 185 }
 186
 187 bool BluezBluetoothRemoteDevice::boolReply(const QString &method) const
 188 {
 189         QDBusReply< bool > reply = device->call(method, m_address);
 190         if (!reply.isValid())
 191                 return false;
 192
 193         return reply.value();
 194 }
 195
 196 void BluezBluetoothRemoteDevice::dbusErrorServiceDiscover(const QDBusError &error)
 197 {
 198         kDebug() << "Error on dbus call for DiscoverServices: " << error.message();
 199         emit serviceDiscoverAvailable("failed",QMap<uint,QString>());
 200 }
 201
 202 void BluezBluetoothRemoteDevice::slotPropertyChanged(const QString &prop, const QDBusVariant &value)
 203 {
 204     emit propertyChanged(prop, value.variant());
 205 }
 206
 207 void BluezBluetoothRemoteDevice::slotDisconnectRequested()
 208 {
 209     emit disconnectRequested();
 210 }
 211
 212 void BluezBluetoothRemoteDevice::slotNodeCreated(const QDBusObjectPath &path)
 213 {
 214     emit nodeCreated(path.path());
 215 }
 216
 217 void BluezBluetoothRemoteDevice::slotNodeRemoved(const QDBusObjectPath &path)
 218 {
 219     emit nodeRemoved(path.path());
 220 }
 221
 222
 223 #include "bluez-bluetoothremotedevice.moc"