Solid
devicemanager.cpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "devicenotifier.h"
00021 #include "devicemanager_p.h"
00022
00023 #include "device.h"
00024 #include "device_p.h"
00025 #include "predicate.h"
00026
00027 #include "ifaces/devicemanager.h"
00028 #include "ifaces/device.h"
00029
00030 #include "soliddefs_p.h"
00031
00032 SOLID_GLOBAL_STATIC(Solid::DeviceManagerPrivate, globalDeviceManager)
00033
00034 Solid::DeviceManagerPrivate::DeviceManagerPrivate()
00035 : m_nullDevice(new DevicePrivate(QString()))
00036 {
00037 loadBackend();
00038
00039 if (managerBackend()!=0) {
00040 connect(managerBackend(), SIGNAL(deviceAdded(QString)),
00041 this, SLOT(_k_deviceAdded(QString)));
00042 connect(managerBackend(), SIGNAL(deviceRemoved(QString)),
00043 this, SLOT(_k_deviceRemoved(QString)));
00044 }
00045 }
00046
00047 Solid::DeviceManagerPrivate::~DeviceManagerPrivate()
00048 {
00049 foreach (DevicePrivate *dev, m_devicesMap) {
00050 delete dev;
00051 }
00052
00053 m_devicesMap.clear();
00054 }
00055
00056 QList<Solid::Device> Solid::Device::allDevices()
00057 {
00058 QList<Device> list;
00059 Ifaces::DeviceManager *backend
00060 = qobject_cast<Ifaces::DeviceManager *>(globalDeviceManager->managerBackend());
00061
00062 if (backend == 0) return list;
00063
00064 QStringList udis = backend->allDevices();
00065
00066 foreach (const QString &udi, udis)
00067 {
00068 list.append(Device(udi));
00069 }
00070
00071 return list;
00072 }
00073
00074 QList<Solid::Device> Solid::Device::listFromQuery(const QString &predicate,
00075 const QString &parentUdi)
00076 {
00077 Predicate p = Predicate::fromString(predicate);
00078
00079 if (p.isValid())
00080 {
00081 return listFromQuery(p, parentUdi);
00082 }
00083 else
00084 {
00085 return QList<Device>();
00086 }
00087 }
00088
00089 QList<Solid::Device> Solid::Device::listFromType(const DeviceInterface::Type &type,
00090 const QString &parentUdi)
00091 {
00092 QList<Device> list;
00093
00094 Ifaces::DeviceManager *backend
00095 = qobject_cast<Ifaces::DeviceManager *>(globalDeviceManager->managerBackend());
00096
00097 if (backend == 0) return list;
00098
00099 QStringList udis = backend->devicesFromQuery(parentUdi, type);
00100
00101 foreach (const QString &udi, udis)
00102 {
00103 list.append(Device(udi));
00104 }
00105
00106 return list;
00107 }
00108
00109 QList<Solid::Device> Solid::Device::listFromQuery(const Predicate &predicate,
00110 const QString &parentUdi)
00111 {
00112 QList<Device> list;
00113
00114 Ifaces::DeviceManager *backend
00115 = qobject_cast<Ifaces::DeviceManager *>(globalDeviceManager->managerBackend());
00116
00117 if (backend == 0) return list;
00118
00119 QSet<QString> udis;
00120 if (predicate.isValid()) {
00121 QSet<DeviceInterface::Type> types = predicate.usedTypes();
00122
00123 foreach (DeviceInterface::Type type, types) {
00124 udis+= QSet<QString>::fromList(backend->devicesFromQuery(parentUdi, type));
00125 }
00126 } else {
00127 udis+= QSet<QString>::fromList(backend->allDevices());
00128 }
00129
00130 foreach (const QString &udi, udis)
00131 {
00132 Device dev(udi);
00133
00134 bool matches = false;
00135
00136 if(!predicate.isValid()) {
00137 matches = true;
00138 } else {
00139 matches = predicate.matches(dev);
00140 }
00141
00142 if (matches)
00143 {
00144 list.append(dev);
00145 }
00146 }
00147
00148 return list;
00149 }
00150
00151 Solid::DeviceNotifier *Solid::DeviceNotifier::instance()
00152 {
00153 return globalDeviceManager;
00154 }
00155
00156 void Solid::DeviceManagerPrivate::_k_deviceAdded(const QString &udi)
00157 {
00158 if (m_devicesMap.contains(udi)) {
00159 DevicePrivate *dev = m_devicesMap[udi];
00160
00161 if (dev->backendObject()==0)
00162
00163
00164 dev->setBackendObject(createBackendObject(udi));
00165 Q_ASSERT(dev->backendObject()!=0);
00166 }
00167
00168 emit deviceAdded(udi);
00169 }
00170
00171 void Solid::DeviceManagerPrivate::_k_deviceRemoved(const QString &udi)
00172 {
00173 if (m_devicesMap.contains(udi)) {
00174 DevicePrivate *dev = m_devicesMap[udi];
00175
00176
00177
00178
00179 Q_ASSERT(dev->backendObject()!=0);
00180 delete dev->backendObject();
00181 Q_ASSERT(dev->backendObject()==0);
00182 }
00183
00184 emit deviceRemoved(udi);
00185 }
00186
00187 void Solid::DeviceManagerPrivate::_k_destroyed(QObject *object)
00188 {
00189 QString udi = m_reverseMap.take(object);
00190
00191 if (!udi.isEmpty()) {
00192 m_devicesMap.remove(udi);
00193 }
00194 }
00195
00196 Solid::DevicePrivate *Solid::DeviceManagerPrivate::findRegisteredDevice(const QString &udi)
00197 {
00198 if (udi.isEmpty()) {
00199 return m_nullDevice.data();
00200 } else if (m_devicesMap.contains(udi)) {
00201 return m_devicesMap[udi];
00202 } else {
00203 Ifaces::Device *iface = createBackendObject(udi);
00204
00205 DevicePrivate *devData = new DevicePrivate(udi);
00206 devData->setBackendObject(iface);
00207
00208 m_devicesMap[udi] = devData;
00209 m_reverseMap[devData] = udi;
00210
00211 connect(devData, SIGNAL(destroyed(QObject *)),
00212 this, SLOT(_k_destroyed(QObject *)));
00213
00214 return devData;
00215 }
00216 }
00217
00218 Solid::Ifaces::Device *Solid::DeviceManagerPrivate::createBackendObject(const QString &udi)
00219 {
00220 Ifaces::DeviceManager *backend = qobject_cast<Ifaces::DeviceManager *>(managerBackend());
00221 Ifaces::Device *iface = 0;
00222
00223 if (backend!= 0) {
00224 QObject *object = backend->createDevice(udi);
00225 iface = qobject_cast<Ifaces::Device *>(object);
00226
00227 if (iface==0) {
00228 delete object;
00229 }
00230 }
00231
00232 return iface;
00233 }
00234
00235 #include "devicenotifier.moc"
00236 #include "devicemanager_p.moc"
00237