rev 14111 - in trunk/packages/kdebase-workspace/debian: . patches
Fathi Boudra
fabo at alioth.debian.org
Fri Mar 20 18:19:32 UTC 2009
Author: fabo
Date: 2009-03-20 18:19:32 +0000 (Fri, 20 Mar 2009)
New Revision: 14111
Added:
trunk/packages/kdebase-workspace/debian/patches/56_solid_changes_kdebluetooth.diff
Modified:
trunk/packages/kdebase-workspace/debian/changelog
trunk/packages/kdebase-workspace/debian/patches/series
Log:
Add TODO: split kdm greeters in a package. (Closes: #520426)
Add 56_solid_changes_kdebluetooth.diff (stolen from kubuntu)
to build kdebluetooth for KDE4.
Modified: trunk/packages/kdebase-workspace/debian/changelog
===================================================================
--- trunk/packages/kdebase-workspace/debian/changelog 2009-03-20 18:05:42 UTC (rev 14110)
+++ trunk/packages/kdebase-workspace/debian/changelog 2009-03-20 18:19:32 UTC (rev 14111)
@@ -1,3 +1,15 @@
+kdebase-workspace (4:4.2.1-3) UNRELEASED; urgency=low
+
+ TODO: split kdm greeters in a package. (Closes: #520426)
+ kdm and kdebase-workspace(-bin) should depends on this new package.
+
+ +++ Changes by Fathi Boudra:
+
+ * Add 56_solid_changes_kdebluetooth.diff (stolen from kubuntu):
+ - Fix kdebluetooth 0.3 build (patch from KDE svn trunk)
+
+ -- Debian Qt/KDE Maintainers <debian-qt-kde at lists.debian.org> Fri, 20 Mar 2009 19:06:26 +0100
+
kdebase-workspace (4:4.2.1-2) experimental; urgency=low
+++ Changes by Modestas Vainius:
Added: trunk/packages/kdebase-workspace/debian/patches/56_solid_changes_kdebluetooth.diff
===================================================================
--- trunk/packages/kdebase-workspace/debian/patches/56_solid_changes_kdebluetooth.diff (rev 0)
+++ trunk/packages/kdebase-workspace/debian/patches/56_solid_changes_kdebluetooth.diff 2009-03-20 18:19:32 UTC (rev 14111)
@@ -0,0 +1,1190 @@
+--- a/solid/bluez/bluez-bluetoothinterface.cpp
++++ b/solid/bluez/bluez-bluetoothinterface.cpp
+@@ -25,6 +25,7 @@
+ #include <solid/control/bluetoothinterface.h>
+
+ #include "bluez-bluetoothremotedevice.h"
++#include "bluez-bluetoothinputdevice.h"
+ #include <KDebug>
+
+
+@@ -43,6 +44,7 @@ public:
+ QString objectPath;
+
+ QMap<QString, BluezBluetoothRemoteDevice *> devices;
++ QMap<QString, BluezBluetoothInputDevice *> inputDevices;
+ };
+
+
+@@ -56,23 +58,6 @@ BluezBluetoothInterface::BluezBluetoothI
+ objectPath, \
+ "org.bluez.Adapter", \
+ signal, this, SLOT(slot));
+-/*
+- connectInterfaceToThis("ModeChanged", slotModeChanged(const QString &));
+- connectInterfaceToThis("DiscoverableTimeoutChanged", slotDiscoverableTimeoutChanged(int));
+- connectInterfaceToThis("MinorClassChanged", slotMinorClassChanged(const QString &));
+- connectInterfaceToThis("NameChanged", slotNameChanged(const QString &));
+- connectInterfaceToThis("DiscoveryStarted", slotDiscoveryStarted());
+- connectInterfaceToThis("DiscoveryCompleted", slotDiscoveryCompleted());
+- connectInterfaceToThis("RemoteDeviceDisappeared", slotRemoteDeviceDisappeared(const QString &));
+- connectInterfaceToThis("RemoteDeviceFound", slotRemoteDeviceFound(const QString &, uint, short));
+- connectInterfaceToThis("RemoteNameUpdated", slotRemoteNameUpdated(const QString &, const QString &));
+- connectInterfaceToThis("RemoteDeviceConnected", slotRemoteDeviceConnected(const QString &));
+- connectInterfaceToThis("RemoteDeviceDisconnected", slotRemoteDeviceDisconnected(const QString &));
+- connectInterfaceToThis("TrustAdded", slotTrustAdded(const QString &));
+- connectInterfaceToThis("TrustRemoved", slotTrustRemoved(const QString &));
+- connectInterfaceToThis("BondingCreated", slotBondingCreated(const QString &));
+- connectInterfaceToThis("BondingRemoved", slotBondingRemoved(const QString &));
+-*/
+
+ connectInterfaceToThis("PropertyChanged", slotPropertyChanged(const QString &, const QVariant &));
+ connectInterfaceToThis("DeviceCreated", slotDeviceCreated(const QDBusObjectPath &));
+@@ -98,21 +83,14 @@ void BluezBluetoothInterface::cancelDevi
+ d->iface.call("CancelDeviceCreation",addr);
+ }
+
+-QString BluezBluetoothInterface::createDevice(const QString &addr) const
++void BluezBluetoothInterface::createDevice(const QString &addr) const
+ {
+- QDBusObjectPath path = objectReply("CreateDevice",addr);
+- return path.path();
++ d->iface.call("CreateDevice",addr);
+ }
+
+-QString BluezBluetoothInterface::createPairedDevice(const QString &addr, const QString &agentUBI, const QString &capab) const
++void BluezBluetoothInterface::createPairedDevice(const QString &addr, const QString &agentUBI, const QString &capab) const
+ {
+- QDBusReply< QDBusObjectPath > reply;
+- reply = d->iface.call("CreatePairedDevice",addr,agentUBI,capab);
+-
+- if (!reply.isValid()) {
+- return QString();
+- }
+- return reply.value().path();
++ d->iface.call("CreatePairedDevice",addr,qVariantFromValue(QDBusObjectPath(agentUBI)),capab);
+ }
+
+ QString BluezBluetoothInterface::findDevice(const QString &addr) const
+@@ -147,7 +125,7 @@ QStringList BluezBluetoothInterface::lis
+
+ void BluezBluetoothInterface::registerAgent(const QString &agentUBI, const QString &capab)
+ {
+- d->iface.call("RegisterAgent",agentUBI,capab);
++ d->iface.call("RegisterAgent",qVariantFromValue(QDBusObjectPath(agentUBI)),capab);
+ }
+
+ void BluezBluetoothInterface::releaseSession()
+@@ -157,7 +135,7 @@ void BluezBluetoothInterface::releaseSes
+
+ void BluezBluetoothInterface::removeDevice(const QString &deviceUBI )
+ {
+- d->iface.call("RemoveDevice",deviceUBI);
++ d->iface.call("RemoveDevice",qVariantFromValue(QDBusObjectPath(deviceUBI)));
+ }
+
+ void BluezBluetoothInterface::requestSession()
+@@ -183,305 +161,20 @@ void BluezBluetoothInterface::stopDiscov
+
+ void BluezBluetoothInterface::unregisterAgent(const QString &agentUBI)
+ {
+- d->iface.call("UnregisterAgent",agentUBI);
+-}
+-
+-
+-
+-/*
+-
+-QString BluezBluetoothInterface::address() const
+-{
+- return stringReply("GetAddress");
+-}
+-
+-QString BluezBluetoothInterface::version() const
+-{
+- return stringReply("GetVersion");
+-}
+-
+-QString BluezBluetoothInterface::revision() const
+-{
+- return stringReply("GetRevision");
+-}
+-
+-QString BluezBluetoothInterface::manufacturer() const
+-{
+- return stringReply("GetManufacturer");
+-}
+-
+-QString BluezBluetoothInterface::company() const
+-{
+- return stringReply("GetCompany");
+-}
+-
+-Solid::Control::BluetoothInterface::Mode BluezBluetoothInterface::mode() const
+-{
+- QString theMode = stringReply("GetMode");
+- Solid::Control::BluetoothInterface::Mode modeEnum;
+- if (theMode == "connectable")
+- {
+- modeEnum = Solid::Control::BluetoothInterface::Connectable;
+- }
+- else if (theMode == "discoverable")
+- {
+- modeEnum = Solid::Control::BluetoothInterface::Discoverable;
+- } else {
+- Q_ASSERT(theMode == "off");
+- modeEnum = Solid::Control::BluetoothInterface::Off;
+- }
+- return modeEnum;
+-}
+-
+-int BluezBluetoothInterface::discoverableTimeout() const
+-{
+- QDBusReply< uint > timeout = d->iface.call("GetDiscoverableTimeout");
+- if (timeout.isValid()) {
+- return timeout.value();
+- }
+-
+- return -1;
+-}
+-
+-bool BluezBluetoothInterface::isDiscoverable() const
+-{
+- return boolReply("IsDiscoverable");
+-}
+-
+-QStringList BluezBluetoothInterface::listConnections() const
+-{
+- QStringList list = listReply("ListConnections");
+- for (int i = 0; i < list.size(); i++) {
+- list[i] = ubi() + '/' + list[i];
+- }
+- return list;
+-}
+-
+-QString BluezBluetoothInterface::majorClass() const
+-{
+- return stringReply("GetMajorClass");
++ d->iface.call("UnregisterAgent",qVariantFromValue(QDBusObjectPath(agentUBI)));
+ }
+
+-QStringList BluezBluetoothInterface::listAvailableMinorClasses() const
+-{
+- return listReply("ListAvailableMinorClasses");
+-}
+-
+-QString BluezBluetoothInterface::minorClass() const
+-{
+- return stringReply("GetMinorClass");
+-}
+-
+-QStringList BluezBluetoothInterface::serviceClasses() const
+-{
+- return listReply("GetServiceClasses");
+-}
+-
+-QString BluezBluetoothInterface::name() const
+-{
+- return stringReply("GetName");
+-}
+
+-QString BluezBluetoothInterface::getRemoteName(const QString &mac)
+-{
+- return stringReply("GetRemoteName",mac);
+-}
+-
+-bool BluezBluetoothInterface::isTrusted(const QString &mac)
+-{
+- return boolReply("IsTrusted",mac);
+-}
+-
+-QStringList BluezBluetoothInterface::listBondings() const
+-{
+- return listReply("ListBondings");
+-}
+-
+-bool BluezBluetoothInterface::isPeriodicDiscoveryActive() const
+-{
+- return boolReply("IsPeriodicDiscovery");
+-}
+
+-bool BluezBluetoothInterface::isPeriodicDiscoveryNameResolvingActive() const
+-{
+- return boolReply("IsPeriodicDiscoveryNameResolving");
+-}
+-
+-QStringList BluezBluetoothInterface::listRemoteDevices() const
+-{
+- QStringList list = listReply("ListRemoteDevices");
+- for (int i = 0; i < list.size(); i++) {
+- list[i] = ubi() + '/' + list[i];
+- }
+- return list;
+-}
+-
+-QStringList BluezBluetoothInterface::listRecentRemoteDevices(const QDateTime &) const
++void BluezBluetoothInterface::slotDeviceCreated(const QDBusObjectPath &path)
+ {
+- return listReply("ListRecentRemoteDevices");
+-}
++ kDebug() << "device created";
+
+-void BluezBluetoothInterface::setMode(const Solid::Control::BluetoothInterface::Mode mode)
+-{
+- QString modeString;
+- switch(mode)
+- {
+- case Solid::Control::BluetoothInterface::Off:
+- modeString = "off";
+- break;
+- case Solid::Control::BluetoothInterface::Discoverable:
+- modeString = "discoverable";
+- break;
+- case Solid::Control::BluetoothInterface::Connectable:
+- modeString = "connectable";
+- break;
++ if (!d->devices.contains(path.path())) {
++ BluezBluetoothRemoteDevice* bluetoothRemoteDev = new BluezBluetoothRemoteDevice(path.path());
++ d->devices.insert(path.path(), bluetoothRemoteDev);
+ }
+- d->iface.call("SetMode", modeString);
+-}
+-
+-void BluezBluetoothInterface::setDiscoverableTimeout(int timeout)
+-{
+- d->iface.call("SetDiscoverableTimeout", (uint)timeout);
+-}
+-
+-void BluezBluetoothInterface::setMinorClass(const QString &minorClass)
+-{
+- d->iface.call("SetMinorClass", minorClass);
+-}
+-
+-void BluezBluetoothInterface::setName(const QString &name)
+-{
+- d->iface.call("SetName", name);
+-}
+
+-void BluezBluetoothInterface::discoverDevices()
+-{
+- d->iface.call("DiscoverDevices");
+-}
+-
+-void BluezBluetoothInterface::discoverDevicesWithoutNameResolving()
+-{
+- d->iface.call("DiscoverDevicesWithoutNameResolving");
+-}
+-
+-void BluezBluetoothInterface::cancelDiscovery()
+-{
+- d->iface.call("CancelDiscovery");
+-}
+-
+-void BluezBluetoothInterface::startPeriodicDiscovery()
+-{
+- d->iface.call("StartPeriodicDiscovery");
+-}
+-
+-void BluezBluetoothInterface::stopPeriodicDiscovery()
+-{
+- d->iface.call("StopPeriodicDiscovery");
+-}
+-
+-void BluezBluetoothInterface::setPeriodicDiscoveryNameResolving(bool nameResolving)
+-{
+- d->iface.call("SetPeriodicDiscoveryNameResolving", nameResolving);
+-}
+-
+-void BluezBluetoothInterface::setTrusted(const QString& mac)
+-{
+- d->iface.call("SetTrusted", mac);
+-}
+-
+-void BluezBluetoothInterface::removeTrust(const QString& mac)
+-{
+- d->iface.call("RemoveTrust", mac);
+-}
+-
+-*/
+-
+-
+-
+-/*
+-
+-void BluezBluetoothInterface::slotModeChanged(const Solid::Control::BluetoothInterface::Mode mode)
+-{
+- emit modeChanged(mode);
+-}
+-
+-void BluezBluetoothInterface::slotDiscoverableTimeoutChanged(int timeout)
+-{
+- emit discoverableTimeoutChanged(timeout);
+-}
+-
+-void BluezBluetoothInterface::slotMinorClassChanged(const QString &minorClass)
+-{
+- emit minorClassChanged(minorClass);
+-}
+-
+-void BluezBluetoothInterface::slotNameChanged(const QString &name)
+-{
+- emit nameChanged(name);
+-}
+-
+-void BluezBluetoothInterface::slotDiscoveryStarted()
+-{
+- emit discoveryStarted();
+-}
+-
+-void BluezBluetoothInterface::slotDiscoveryCompleted()
+-{
+- emit discoveryCompleted();
+-}
+-
+-void BluezBluetoothInterface::slotRemoteDeviceFound(const QString &address, uint deviceClass, short rssi)
+-{
+- QString remoteubi = QString("%1/%2").arg(ubi()).arg(address);
+- emit remoteDeviceFound(remoteubi, deviceClass, rssi);
+-}
+-
+-void BluezBluetoothInterface::slotRemoteDeviceDisappeared(const QString &address)
+-{
+- QString remoteubi = QString("%1/%2").arg(ubi()).arg(address);
+- emit remoteDeviceDisappeared(remoteubi);
+-}
+-
+-void BluezBluetoothInterface::slotRemoteNameUpdated(const QString &address, const QString& name)
+-{
+- emit remoteNameUpdated(address,name);
+-}
+-
+-void BluezBluetoothInterface::slotRemoteDeviceConnected(const QString &address)
+-{
+- emit remoteDeviceConnected(address);
+-}
+-
+-void BluezBluetoothInterface::slotRemoteDeviceDisconnected(const QString &address)
+-{
+- emit remoteDeviceDisconnected(address);
+-}
+-
+-void BluezBluetoothInterface::slotTrustAdded(const QString &address)
+-{
+- emit trustAdded(address);
+-}
+-
+-void BluezBluetoothInterface::slotTrustRemoved(const QString &address)
+-{
+- emit trustRemoved(address);
+-}
+-
+-void BluezBluetoothInterface::slotBondingCreated(const QString &address)
+-{
+- emit bondingCreated(address);
+-}
+-
+-void BluezBluetoothInterface::slotBondingRemoved(const QString &address)
+-{
+- emit bondingRemoved(address);
+-}
+-
+-*/
+-
+-void BluezBluetoothInterface::slotDeviceCreated(const QDBusObjectPath &path)
+-{
+- kDebug() << "device created";
+ emit deviceCreated(path.path());
+ }
+
+@@ -523,6 +216,19 @@ QObject *BluezBluetoothInterface::create
+ return bluetoothInterface;
+ }
+
++QObject *BluezBluetoothInterface::createBluetoothInputDevice(const QString &ubi)
++{
++ BluezBluetoothInputDevice *bluetoothInputDev;
++ if (d->inputDevices.contains(ubi)) {
++ bluetoothInputDev = d->inputDevices[ubi];
++ } else {
++ bluetoothInputDev = new BluezBluetoothInputDevice(ubi);
++ d->inputDevices.insert(ubi, bluetoothInputDev);
++ }
++ return bluetoothInputDev;
++}
++
++
+
+ /******************* DBus Calls *******************************/
+
+@@ -574,10 +280,13 @@ QDBusObjectPath BluezBluetoothInterface:
+
+ if (param.isEmpty())
+ reply = d->iface.call(method);
+- else
++ else {
++ qDebug() << "ObjectReply calling: " << method << " " << param;
+ reply = d->iface.call(method, param);
++ }
+
+ if (reply.isValid()) {
++ qDebug() << "ObjectReply Valid? "<< reply.value().path();
+ return reply.value();
+ }
+
+--- a/solid/bluez/bluez-bluetoothinterface.h
++++ b/solid/bluez/bluez-bluetoothinterface.h
+@@ -27,6 +27,7 @@
+ #include <QtDBus>
+ #include <QDBusVariant>
+ #include <QDBusObjectPath>
++#include <QString>
+
+ #include <solid/control/ifaces/bluetoothinterface.h>
+
+@@ -42,34 +43,11 @@ public:
+ BluezBluetoothInterface(const QString & objectPath);
+ virtual ~BluezBluetoothInterface();
+ QString ubi() const;
+-/*
+- QString address() const;
+- QString version() const;
+- QString revision() const;
+- QString manufacturer() const;
+- QString company() const;
+- Solid::Control::BluetoothInterface::Mode mode() const;
+- int discoverableTimeout() const;
+- bool isDiscoverable() const;
+- QStringList listConnections() const;
+- QString majorClass() const;
+- QStringList listAvailableMinorClasses() const;
+- QString minorClass() const;
+- QStringList serviceClasses() const;
+- QString name() const;
+- QStringList listBondings() const;
+- bool isPeriodicDiscoveryActive() const;
+- bool isPeriodicDiscoveryNameResolvingActive() const;
+- QStringList listRemoteDevices() const;
+- QStringList listRecentRemoteDevices(const QDateTime &) const;
+- QString getRemoteName(const QString &);
+- bool isTrusted(const QString &);
+-
+-*/
++
+ QObject *createBluetoothRemoteDevice(const QString &);
+-
+- QString createDevice(const QString &) const;
+- QString createPairedDevice(const QString &,const QString &,const QString &) const;
++ QObject *createBluetoothInputDevice(const QString &);
++ void createDevice(const QString &) const;
++ void createPairedDevice(const QString &,const QString &,const QString &) const;
+ QString findDevice(const QString &) const;
+ QMap< QString, QVariant > getProperties() const;
+ QStringList listDevices() const;
+@@ -87,36 +65,6 @@ public Q_SLOTS:
+ void stopDiscovery();
+ void unregisterAgent(const QString &);
+
+-/*
+- void setMode(const Solid::Control::BluetoothInterface::Mode);
+- void setDiscoverableTimeout(int);
+- void setMinorClass(const QString &);
+- void setName(const QString &);
+- void discoverDevices();
+- void discoverDevicesWithoutNameResolving();
+- void cancelDiscovery();
+- void startPeriodicDiscovery();
+- void stopPeriodicDiscovery();
+- void setPeriodicDiscoveryNameResolving(bool);
+- void setTrusted(const QString &);
+- void removeTrust(const QString &);
+-
+- void slotModeChanged(const Solid::Control::BluetoothInterface::Mode mode);
+- void slotDiscoverableTimeoutChanged(int timeout);
+- void slotMinorClassChanged(const QString &minor);
+- void slotNameChanged(const QString &name);
+- void slotDiscoveryStarted();
+- void slotDiscoveryCompleted();
+- void slotRemoteDeviceFound(const QString &ubi, uint deviceClass, short rssi);
+- void slotRemoteDeviceDisappeared(const QString &ubi);
+- void slotRemoteNameUpdated(const QString &, const QString &);
+- void slotRemoteDeviceConnected(const QString&);
+- void slotRemoteDeviceDisconnected(const QString&);
+- void slotTrustAdded(const QString&);
+- void slotTrustRemoved(const QString&);
+- void slotBondingCreated(const QString&);
+- void slotBondingRemoved(const QString&);
+-*/
+ void slotDeviceCreated(const QDBusObjectPath &);
+ void slotDeviceDisappeared(const QString &);
+ void slotDeviceFound(const QString &, const QMap< QString, QVariant > &);
+--- a/solid/bluez/bluez-bluetoothmanager.cpp
++++ b/solid/bluez/bluez-bluetoothmanager.cpp
+@@ -104,6 +104,7 @@ QStringList BluezBluetoothManager::bluet
+
+ QString BluezBluetoothManager::defaultInterface() const
+ {
++ kDebug() << "Calling Backend Default Interface";
+ QDBusReply< QDBusObjectPath > path = d->manager.call("DefaultAdapter");
+ if (!path.isValid())
+ return QString();
+@@ -132,6 +133,16 @@ QObject * BluezBluetoothManager::createI
+ return bluetoothInterface;
+ }
+
++void BluezBluetoothManager::removeInterface(const QString& ubi)
++{
++
++ if (d->interfaces.contains(ubi)) {
++ kDebug() << "Removing Interface" << ubi;
++ BluezBluetoothInterface * bluetoothInterface = d->interfaces.take(ubi);
++ bluetoothInterface = 0;
++ }
++}
++
+ /*
+ KJob *BluezBluetoothManager::setupInputDevice(const QString &ubi)
+ {
+--- a/solid/bluez/bluez-bluetoothremotedevice.cpp
++++ b/solid/bluez/bluez-bluetoothremotedevice.cpp
+@@ -42,6 +42,7 @@ BluezBluetoothRemoteDevice::BluezBluetoo
+ m_adapter = m_objectPath.left(objectPath.size() - 18);
+ m_address = m_objectPath.right(17);
+
++ kdDebug() << "Connecting to ObjectPath: " << objectPath;
+
+ device = new QDBusInterface("org.bluez", objectPath,
+ "org.bluez.Device", QDBusConnection::systemBus());
+@@ -79,7 +80,7 @@ QMap<QString,QVariant> BluezBluetoothRem
+
+ void BluezBluetoothRemoteDevice::setProperty(const QString &name, const QVariant &value)
+ {
+- device->call("SetProperty",name,value);
++ device->call("SetProperty",name,qVariantFromValue(QDBusVariant(value)));
+ }
+
+ void BluezBluetoothRemoteDevice::discoverServices(const QString& pattern) const
+--- a/solid/bluez/bluez-bluetoothmanager.h
++++ b/solid/bluez/bluez-bluetoothmanager.h
+@@ -43,6 +43,7 @@ public:
+ virtual ~BluezBluetoothManager();
+ QStringList bluetoothInterfaces() const;
+ QObject * createInterface(const QString &);
++ void removeInterface(const QString& ubi);
+ // QStringList bluetoothInputDevices() const;
+ QString defaultInterface() const;
+ QString findInterface(const QString &) const;
+--- a/libs/solid/control/bluetoothinputdevice.cpp
++++ b/libs/solid/control/bluetoothinputdevice.cpp
+@@ -91,8 +91,8 @@ void Solid::Control::BluetoothInputDevic
+ FrontendObjectPrivate::setBackendObject(object);
+
+ if (object) {
+- QObject::connect(object, SIGNAL(propertyChanged(QString,QVariant)),
+- parent(), SIGNAL(propertyChanged(QString,QVariant)));
++ QObject::connect(object, SIGNAL(propertyChanged(const QString&,const QVariant&)),
++ parent(), SIGNAL(propertyChanged(const QString,const QVariant&)));
+ }
+ }
+
+--- a/libs/solid/control/bluetoothinterface.cpp
++++ b/libs/solid/control/bluetoothinterface.cpp
+@@ -25,7 +25,7 @@
+ #include <QStringList>
+ #include <QVariant>
+
+-#include <kdebug.h>
++#include <KDebug>
+
+ #include "ifaces/bluetoothinterface.h"
+
+@@ -49,9 +49,12 @@ public:
+ void setBackendObject(QObject *object);
+
+ QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> findRegisteredBluetoothRemoteDevice(const QString &ubi) const;
++ QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> findRegisteredBluetoothInputDevice(const QString &ubi) const;
+
+ mutable QMap<QString, QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> > remoteDeviceMap;
++ mutable QMap<QString, QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> > inputDeviceMap;
+ mutable BluetoothRemoteDevice invalidDevice;
++ mutable BluetoothInputDevice invalidInputDevice;
+ };
+ }
+ }
+@@ -65,30 +68,39 @@ Solid::Control::BluetoothInterface::Blue
+ {
+ const BluetoothInterface &device = BluetoothManager::self().findBluetoothInterface(ubi);
+ d->setBackendObject(device.d->backendObject());
++ QObject::connect(d->backendObject(), SIGNAL(deviceCreated(const QString &)),this, SLOT(slotDeviceCreated(const QString &)));
+ }
+
+ Solid::Control::BluetoothInterface::BluetoothInterface(QObject *backendObject)
+ : QObject(), d(new BluetoothInterfacePrivate(this))
+ {
+ d->setBackendObject(backendObject);
++ QObject::connect(d->backendObject(), SIGNAL(deviceCreated(const QString &)),this, SLOT(slotDeviceCreated(const QString &)));
+ }
+
+ Solid::Control::BluetoothInterface::BluetoothInterface(const BluetoothInterface &device)
+ : QObject(), d(new BluetoothInterfacePrivate(this))
+ {
+ d->setBackendObject(device.d->backendObject());
++ QObject::connect(d->backendObject(), SIGNAL(deviceCreated(const QString &)),this, SLOT(slotDeviceCreated(const QString &)));
+ }
+
+ Solid::Control::BluetoothInterface::~BluetoothInterface()
+ {
+ // Delete all the interfaces, they are now outdated
+ typedef QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> BluetoothRemoteDeviceIfacePair;
++ typedef QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> BluetoothInputDeviceIfacePair;
+
+ // Delete all the devices, they are now outdated
+- foreach (const BluetoothRemoteDeviceIfacePair &pair, d->remoteDeviceMap) {
++ foreach (const BluetoothRemoteDeviceIfacePair &pair, d->remoteDeviceMap.values()) {
+ delete pair.first;
+ delete pair.second;
+ }
++ foreach (const BluetoothInputDeviceIfacePair &pair, d->inputDeviceMap.values()) {
++ delete pair.first;
++ delete pair.second;
++ }
++
+ }
+
+ Solid::Control::BluetoothInterface &Solid::Control::BluetoothInterface::operator=(const Solid::Control::BluetoothInterface & dev)
+@@ -108,9 +120,12 @@ void Solid::Control::BluetoothInterface:
+ SOLID_CALL(Ifaces::BluetoothInterface *, d->backendObject(), cancelDeviceCreation(address));
+ }
+
+-QString Solid::Control::BluetoothInterface::createPairedDevice(const QString &address,const QString &adapterPath, const QString &capab) const
++void Solid::Control::BluetoothInterface::createPairedDevice(const QString &address,const QString &adapterPath, const QString &capab) const
+ {
+- return_SOLID_CALL(Ifaces::BluetoothInterface *, d->backendObject(), QString(), createPairedDevice(address,adapterPath,capab));
++ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(d->backendObject());
++ if (backend == 0)
++ return;
++ backend->createPairedDevice(address,adapterPath,capab);
+ }
+
+ QMap<QString, QVariant> Solid::Control::BluetoothInterface::getProperties() const
+@@ -137,7 +152,7 @@ Solid::Control::BluetoothRemoteDeviceLis
+
+ Solid::Control::BluetoothRemoteDeviceList list;
+ foreach (const QString& ubi,ubis) {
+- BluetoothRemoteDevice remoteDevice = findBluetoothRemoteDevice(ubi);
++ BluetoothRemoteDevice* remoteDevice = findBluetoothRemoteDeviceUBI(ubi);
+ list.append(remoteDevice);
+ }
+ return list;
+@@ -184,13 +199,13 @@ void Solid::Control::BluetoothInterface:
+ }
+
+
+-Solid::Control::BluetoothRemoteDevice Solid::Control::BluetoothInterface::findBluetoothRemoteDevice(const QString &address) const
++Solid::Control::BluetoothRemoteDevice Solid::Control::BluetoothInterface::findBluetoothRemoteDeviceAddr(const QString &address) const
+ {
+ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(d->backendObject());
+ if (backend == 0)
+ return d->invalidDevice;
+
+- const QString ubi = backend->findDevice(address);
++ const QString ubi = getBluetoothRemoteDeviceUBI(address);
+
+ QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> pair = d->findRegisteredBluetoothRemoteDevice(ubi);
+
+@@ -201,18 +216,56 @@ Solid::Control::BluetoothRemoteDevice So
+ }
+ }
+
+-Solid::Control::BluetoothRemoteDevice * Solid::Control::BluetoothInterface::createBluetoothRemoteDevice(const QString &address)
++
++const QString Solid::Control::BluetoothInterface::getBluetoothRemoteDeviceUBI(const QString &address) const
+ {
+ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(d->backendObject());
+ if (backend == 0)
+- return 0;
++ return "";
++
++ const QString ubi = backend->findDevice(address);
++ return ubi;
++}
+
+- const QString ubi = backend->createDevice(address);
+
++void Solid::Control::BluetoothInterface::createBluetoothRemoteDevice(const QString &address)
++{
++ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(d->backendObject());
++ if (backend == 0)
++ return;
++ backend->createDevice(address);
++}
++
++
++Solid::Control::BluetoothRemoteDevice* Solid::Control::BluetoothInterface::findBluetoothRemoteDeviceUBI(const QString &ubi) const
++{
+ QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> pair = d->findRegisteredBluetoothRemoteDevice(ubi);
+ return pair.first;
+ }
+
++Solid::Control::BluetoothInputDevice* Solid::Control::BluetoothInterface::findBluetoothInputDeviceUBI(const QString &ubi) const
++{
++ QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair = d->findRegisteredBluetoothInputDevice(ubi);
++ return pair.first;
++}
++
++void Solid::Control::BluetoothInterface::slotDeviceCreated(const QString& ubi)
++{
++
++ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(d->backendObject());
++ Ifaces::BluetoothRemoteDevice *iface = 0;
++
++ if (backend != 0) {
++ iface = qobject_cast<Ifaces::BluetoothRemoteDevice *>(backend->createBluetoothRemoteDevice(ubi));
++ }
++
++ if (iface != 0) {
++ BluetoothRemoteDevice *device = new BluetoothRemoteDevice(iface);
++
++ QPair<BluetoothRemoteDevice *, Ifaces::BluetoothRemoteDevice *> pair(device, iface);
++ d->remoteDeviceMap[ubi] = pair;
++ }
++}
+
+ QString Solid::Control::BluetoothInterface::address() const
+ {
+@@ -492,8 +545,6 @@ void Solid::Control::BluetoothInterfaceP
+ QObject::connect(object, SIGNAL(propertyChanged(const QString &,const QVariant &)),
+ parent(), SIGNAL(propertyChanged(const QString &, const QVariant &)));
+
+-
+-
+ }
+ }
+
+@@ -523,4 +574,30 @@ QPair<Solid::Control::BluetoothRemoteDev
+ }
+ }
+
++QPair<Solid::Control::BluetoothInputDevice *, Solid::Control::Ifaces::BluetoothInputDevice *> Solid::Control::BluetoothInterfacePrivate::findRegisteredBluetoothInputDevice(const QString &ubi) const
++{
++ if (inputDeviceMap.contains(ubi)) {
++ return inputDeviceMap[ubi];
++ } else {
++ Ifaces::BluetoothInterface *backend = qobject_cast<Ifaces::BluetoothInterface *>(backendObject());
++ Ifaces::BluetoothInputDevice *iface = 0;
++
++ if (backend != 0) {
++ iface = qobject_cast<Ifaces::BluetoothInputDevice *>(backend->createBluetoothInputDevice(ubi));
++ }
++
++ if (iface != 0) {
++ BluetoothInputDevice *device = new BluetoothInputDevice(iface);
++
++ QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *> pair(device, iface);
++ inputDeviceMap[ubi] = pair;
++
++ return pair;
++ } else {
++ return QPair<BluetoothInputDevice *, Ifaces::BluetoothInputDevice *>(0, 0);
++ }
++
++ }
++}
++
+ #include "bluetoothinterface.moc"
+--- a/libs/solid/control/bluetoothinterface.h
++++ b/libs/solid/control/bluetoothinterface.h
+@@ -28,7 +28,9 @@
+ #include <QtCore/QMap>
+
+ #include "bluetoothremotedevice.h"
++#include "bluetoothinputdevice.h"
+ #include "ifaces/bluetoothremotedevice.h"
++#include "ifaces/bluetoothinputdevice.h"
+
+
+
+@@ -37,7 +39,7 @@ namespace Solid
+ namespace Control
+ {
+ class BluetoothRemoteDevice;
+-typedef QList<BluetoothRemoteDevice> BluetoothRemoteDeviceList;
++typedef QList<BluetoothRemoteDevice*> BluetoothRemoteDeviceList;
+ class BluetoothInterfacePrivate;
+
+ /**
+@@ -115,7 +117,8 @@ public:
+ * @param ubi the identifier of the bluetooth device to instantiate
+ * @returns a bluetooth object, if a bluetooth device having the given UBI, for this interface exists, 0 otherwise
+ */
+- Solid::Control::BluetoothRemoteDevice* createBluetoothRemoteDevice(const QString &address);
++ //Solid::Control::BluetoothRemoteDevice* createBluetoothRemoteDevice(const QString &address);
++ void createBluetoothRemoteDevice(const QString &address);
+
+ /**
+ * Finds a BluetoothRemoteDevice object given its UBI.
+@@ -123,7 +126,13 @@ public:
+ * @param ubi the identifier of the bluetooth remote device to find from this bluetooth interface
+ * @returns a valid BluetoothRemoteDevice object if a remote device having the given UBI for this interface exists, an invalid BluetoothRemoteDevice object otherwise.
+ */
+- Solid::Control::BluetoothRemoteDevice findBluetoothRemoteDevice(const QString &address) const;
++ const QString getBluetoothRemoteDeviceUBI(const QString &address) const;
++
++ Solid::Control::BluetoothRemoteDevice findBluetoothRemoteDeviceAddr(const QString &addr) const;
++
++ Solid::Control::BluetoothRemoteDevice* findBluetoothRemoteDeviceUBI(const QString &ubi) const;
++
++ Solid::Control::BluetoothInputDevice* findBluetoothInputDeviceUBI(const QString &ubi) const;
+
+ /**
+ * Retrieves the MAC address of the bluetooth interface/adapter.
+@@ -296,7 +305,7 @@ public:
+ // bool isTrusted(const QString &);
+
+
+- QString createPairedDevice(const QString &, const QString &, const QString &) const;
++ void createPairedDevice(const QString &, const QString &, const QString &) const;
+
+ QMap< QString, QVariant > getProperties() const;
+
+@@ -557,6 +566,9 @@ private:
+ QVariant getProperty(const QString&) const;
+ BluetoothInterfacePrivate * const d;
+
++private slots:
++ void slotDeviceCreated(const QString& ubi);
++
+ };
+
+ } //Control
+--- a/libs/solid/control/bluetoothmanager.cpp
++++ b/libs/solid/control/bluetoothmanager.cpp
+@@ -58,6 +58,7 @@ public:
+
+ void _k_interfaceAdded(const QString &ubi);
+ void _k_interfaceRemoved(const QString &ubi);
++ void _k_defaultInterfaceChanged(const QString &ubi);
+ void _k_interfaceDestroyed(QObject *object);
+ /*
+ void _k_inputDeviceCreated(const QString &ubi);
+@@ -95,7 +96,7 @@ Solid::Control::BluetoothManager::~Bluet
+ typedef QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> BluetoothInterfaceIfacePair;
+
+ // Delete all the devices, they are now outdated
+- foreach (const BluetoothInterfaceIfacePair &pair, d->bluetoothInterfaceMap) {
++ foreach (const BluetoothInterfaceIfacePair &pair, d->bluetoothInterfaceMap.values()) {
+ delete pair.first;
+ delete pair.second;
+ }
+@@ -110,6 +111,8 @@ Solid::Control::BluetoothInterfaceList S
+
+ if (backend == 0) return list;
+
++ kDebug() << "UBI List " << ubiList;
++
+ foreach (const QString &ubi, ubiList) {
+ QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = d->findRegisteredBluetoothInterface(ubi);
+
+@@ -239,7 +242,9 @@ void Solid::Control::BluetoothManager::r
+ */
+ void Solid::Control::BluetoothManagerPrivate::_k_interfaceAdded(const QString &ubi)
+ {
+- QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = bluetoothInterfaceMap.take(ubi);
++ kDebug() << "Size of InterfaceList " << bluetoothInterfaceMap.size();
++ QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = findRegisteredBluetoothInterface(ubi);
++/* QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair = bluetoothInterfaceMap.take(ubi);
+
+ if (pair.first != 0) {
+ // Oops, I'm not sure it should happen...
+@@ -247,7 +252,7 @@ void Solid::Control::BluetoothManagerPri
+
+ delete pair.first;
+ delete pair.second;
+- }
++ }*/
+
+ emit q->interfaceAdded(ubi);
+ }
+@@ -261,11 +266,19 @@ void Solid::Control::BluetoothManagerPri
+ delete pair.second;
+ }
+
++ Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(managerBackend());
++ backend->removeInterface(ubi);
+ emit q->interfaceRemoved(ubi);
+ }
+
++void Solid::Control::BluetoothManagerPrivate::_k_defaultInterfaceChanged(const QString &ubi)
++{
++ emit q->defaultInterfaceChanged(ubi);
++}
++
+ void Solid::Control::BluetoothManagerPrivate::_k_interfaceDestroyed(QObject *object)
+ {
++ kDebug() << "Interface detroyed";
+ Ifaces::BluetoothInterface *device = qobject_cast<Ifaces::BluetoothInterface *>(object);
+
+ if (device != 0) {
+@@ -323,6 +336,9 @@ void Solid::Control::BluetoothManagerPri
+ q, SLOT(_k_interfaceAdded(const QString &)));
+ QObject::connect(newBackend, SIGNAL(interfaceRemoved(const QString &)),
+ q, SLOT(_k_interfaceRemoved(const QString &)));
++ QObject::connect(newBackend, SIGNAL(defaultInterfaceChanged(const QString &)),
++ q, SLOT(_k_defaultInterfaceChanged(const QString &)));
++
+ /*
+ QObject::connect(newBackend, SIGNAL(inputDeviceCreated(const QString &)),
+ q, SLOT(_k_inputDeviceCreated(const QString &)));
+@@ -334,17 +350,22 @@ void Solid::Control::BluetoothManagerPri
+
+ QPair<Solid::Control::BluetoothInterface *, Solid::Control::Ifaces::BluetoothInterface *> Solid::Control::BluetoothManagerPrivate::findRegisteredBluetoothInterface(const QString &ubi) const
+ {
++
++ kDebug() << "findRegisteredBluetoothInterface " << ubi;
+ if (bluetoothInterfaceMap.contains(ubi)) {
+ return bluetoothInterfaceMap[ubi];
+ } else {
++ kDebug() << "Creating New Interface " << ubi;
+ Ifaces::BluetoothManager *backend = qobject_cast<Ifaces::BluetoothManager *>(managerBackend());
+ Ifaces::BluetoothInterface *iface = 0;
+
+ if (backend != 0) {
++ kDebug() << "Calling Backend to Creating New Interface " << ubi;
+ iface = qobject_cast<Ifaces::BluetoothInterface *>(backend->createInterface(ubi));
+ }
+
+ if (iface != 0) {
++ kDebug() << "BackendIface created ";
+ BluetoothInterface *device = new BluetoothInterface(iface);
+ QPair<BluetoothInterface *, Ifaces::BluetoothInterface *> pair(device, iface);
+ QObject::connect(iface, SIGNAL(destroyed(QObject *)),
+--- a/libs/solid/control/bluetoothmanager.h
++++ b/libs/solid/control/bluetoothmanager.h
+@@ -188,6 +188,7 @@ private:
+
+ Q_PRIVATE_SLOT(d, void _k_interfaceAdded(const QString &))
+ Q_PRIVATE_SLOT(d, void _k_interfaceRemoved(const QString &))
++ Q_PRIVATE_SLOT(d, void _k_defaultInterfaceChanged(const QString &))
+ Q_PRIVATE_SLOT(d, void _k_interfaceDestroyed(QObject *))
+ /*
+ Q_PRIVATE_SLOT(d, void _k_inputDeviceCreated(const QString &))
+--- a/libs/solid/control/bluetoothremotedevice.cpp
++++ b/libs/solid/control/bluetoothremotedevice.cpp
+@@ -88,6 +88,15 @@ QMap<QString,QVariant> Solid::Control::B
+ return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), (QMap< QString,QVariant >()), getProperties());
+ }
+
++QVariant Solid::Control::BluetoothRemoteDevice::getProperty(const QString &key)
++{
++ QMap<QString, QVariant> props = getProperties();
++ if (props.contains(key))
++ return props[key];
++ else
++ return QVariant();
++}
++
+ QStringList Solid::Control::BluetoothRemoteDevice::listNodes()
+ {
+ Q_D(const BluetoothRemoteDevice);
+@@ -113,14 +122,65 @@ void Solid::Control::BluetoothRemoteDevi
+ }
+
+
++QString Solid::Control::BluetoothRemoteDevice::address()
++{
++ QVariant var = getProperty("Address");
++
++ if (var.isValid())
++ return var.value<QString>();
++ else
++ return QString();
+
+-/*
+-QString Solid::Control::BluetoothRemoteDevice::address() const
++// Q_D(const BluetoothRemoteDevice);
++// return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), address());
++}
++
++bool Solid::Control::BluetoothRemoteDevice::isTrusted()
+ {
+- Q_D(const BluetoothRemoteDevice);
+- return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), address());
++ QVariant var = getProperty("Trusted");
++
++ if (var.isValid())
++ return var.value<bool>();
++ else
++ return false;
++}
++
++void Solid::Control::BluetoothRemoteDevice::setTrusted(bool trust)
++{
++ setProperty("Trusted",QVariant(trust));
++}
++
++QString Solid::Control::BluetoothRemoteDevice::icon()
++{
++ QVariant var = getProperty("Icon");
++
++ if (var.isValid())
++ return var.value<QString>();
++ else
++ return "";
++}
++
++QStringList Solid::Control::BluetoothRemoteDevice::uuids()
++{
++ QVariant var = getProperty("UUIDs");
++
++ if (var.isValid())
++ return var.value<QStringList>();
++ else
++ return QStringList();
++}
++
++bool Solid::Control::BluetoothRemoteDevice::isConnected()
++{
++ QVariant var = getProperty("Connected");
++
++ if (var.isValid())
++ return var.value<bool>();
++ else
++ return false;
+ }
+
++/*
+ bool Solid::Control::BluetoothRemoteDevice::isConnected() const
+ {
+ Q_D(const BluetoothRemoteDevice);
+@@ -168,12 +228,21 @@ QStringList Solid::Control::BluetoothRem
+ Q_D(const BluetoothRemoteDevice);
+ return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QStringList(), serviceClasses());
+ }
+-QString Solid::Control::BluetoothRemoteDevice::name() const
++*/
++
++QString Solid::Control::BluetoothRemoteDevice::name()
+ {
+- Q_D(const BluetoothRemoteDevice);
+- return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), name());
++ QVariant var = getProperty("Name");
++
++ if (var.isValid())
++ return var.value<QString>();
++ else
++ return QString();
++
++// return_SOLID_CALL(Ifaces::BluetoothRemoteDevice *, d->backendObject(), QString(), name());
+ }
+
++/*
+ QString Solid::Control::BluetoothRemoteDevice::alias() const
+ {
+ Q_D(const BluetoothRemoteDevice);
+--- a/libs/solid/control/bluetoothremotedevice.h
++++ b/libs/solid/control/bluetoothremotedevice.h
+@@ -82,11 +82,46 @@ public:
+ bool operator==(const BluetoothRemoteDevice & other) const;
+
+ /**
+- * The UBI of the remote de device.
++ * The UBI of the remote device.
+ */
+ QString ubi() const;
+
+ /**
++ * The address of the remote device.
++ */
++ QString address();
++
++ /**
++ * The name of the remote device.
++ */
++ QString name();
++
++ /**
++ * The icon of the remote device.
++ */
++ QString icon();
++
++ /**
++ * The Trust state of the remote device.
++ */
++ bool isTrusted();
++
++ /**
++ * Set the Trust state of the remote device.
++ */
++ void setTrusted(bool);
++
++ /**
++ * Returns the service uuids of the remote device.
++ */
++ QStringList uuids();
++
++ /**
++ * The Connection state of the remote device.
++ */
++ bool isConnected();
++
++ /**
+ * Retrieve all properties from the remote device.
+ *
+ * @returns a hash of named properties
+@@ -157,6 +192,9 @@ protected:
+
+ private:
+ Q_PRIVATE_SLOT(d_func(), void _k_destroyed(QObject *))
++
++
++ QVariant getProperty(const QString &key);
+ };
+
+ } //Control
+--- a/libs/solid/control/ifaces/bluetoothinterface.h
++++ b/libs/solid/control/ifaces/bluetoothinterface.h
+@@ -240,7 +240,7 @@ public:
+ */
+
+
+- virtual QString createPairedDevice(const QString &, const QString &, const QString &) const = 0;
++ virtual void createPairedDevice(const QString &, const QString &, const QString &) const = 0;
+
+ virtual QMap< QString, QVariant > getProperties() const = 0;
+
+@@ -248,7 +248,8 @@ public:
+
+ virtual QString findDevice(const QString &) const = 0;
+
+- virtual QString createDevice(const QString &) const = 0;
++ //virtual QString createDevice(const QString &) const = 0;
++ virtual void createDevice(const QString &) const = 0;
+
+
+
+@@ -320,7 +321,9 @@ public:
+ * @param ubi the identifier of the bluetooth remote device instantiated
+ * @returns a new BluetoothRemoteDevice object if there's a device having the given UBI, 0 otherwise
+ */
+- virtual QObject *createBluetoothRemoteDevice(const QString &address) = 0;
++ virtual QObject *createBluetoothRemoteDevice(const QString &ubi) = 0;
++
++ virtual QObject *createBluetoothInputDevice(const QString &ubi) = 0;
+
+ /**
+ * Marks the device as trusted.
+--- a/libs/solid/control/ifaces/bluetoothmanager.h
++++ b/libs/solid/control/ifaces/bluetoothmanager.h
+@@ -89,6 +89,13 @@ public:
+ virtual QObject *createInterface(const QString &ubi) = 0;
+
+ /**
++ * Removes a BluetoothInterface object from this backend given its UBI.
++ *
++ * @param ubi the identifier of the bluetooth interface instantiated
++ */
++ virtual void removeInterface(const QString &ubi) = 0;
++
++ /**
+ * Retrieves the list of Universal Bluetooth Identifiers (UBIs) of bluetooth input devices
+ * which are configured in the system. Configured means also not connected devices.
+ *
Modified: trunk/packages/kdebase-workspace/debian/patches/series
===================================================================
--- trunk/packages/kdebase-workspace/debian/patches/series 2009-03-20 18:05:42 UTC (rev 14110)
+++ trunk/packages/kdebase-workspace/debian/patches/series 2009-03-20 18:19:32 UTC (rev 14111)
@@ -14,4 +14,5 @@
23_do_not_depend_on_bindings.diff
24_do_not_search_for_libeet.diff
25_task.h_forward_decl_netwininfo.diff
+56_solid_changes_kdebluetooth.diff
97_fix_target_link_libraries.diff
More information about the pkg-kde-commits
mailing list