kdelibs/patches/kdelibs-4.9.4-udisks2-kfileplacesdevicecache.patch

diff --git a/kfile/CMakeLists.txt b/kfile/CMakeLists.txt
index ceae140..c7c4d3d 100644
--- a/kfile/CMakeLists.txt
+++ b/kfile/CMakeLists.txt
@@ -20,6 +20,7 @@ set(kfile_LIB_SRCS
   kfilefiltercombo.cpp
   kfiletreeview.cpp
   kfilewidget.cpp
+  kfileplacesdevicecache.cpp
   kfileplacesitem.cpp
   kfileplacesmodel.cpp
   kfileplacessharedbookmarks.cpp
@@ -63,6 +64,7 @@ install( FILES
   kdirselectdialog.h
   kdirsortfilterproxymodel.h
   kfilefiltercombo.h
+  kfileplacesdevicecache.h
   kfileplacesmodel.h
   kfileplacesview.h
   kfilepreviewgenerator.h
diff --git a/kfile/kfileplacesdevicecache.cpp b/kfile/kfileplacesdevicecache.cpp
new file mode 100644
index 0000000..40f7242
--- /dev/null
+++ b/kfile/kfileplacesdevicecache.cpp
@@ -0,0 +1,174 @@
+/*
+  Copyright (C) 2012 Dan Vrátil <dvratil@redhat.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License version 2 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public License
+  along with this library; see the file COPYING.LIB.  If not, write to
+  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+  Boston, MA 02110-1301, USA.
+*/
+
+#include "kfileplacesdevicecache.h"
+
+#include <QMutex>
+#include <QtConcurrentRun>
+#include <QFutureWatcher>
+#include <QTimer>
+
+#include <kprotocolinfo.h>
+#include <solid/predicate.h>
+#include <solid/device.h>
+#include <solid/devicenotifier.h>
+#include <solid/genericinterface.h>
+
+#include <kdebug.h>
+
+KFilePlacesDeviceCache* KFilePlacesDeviceCache::s_instance = 0;
+
+class KFilePlacesDeviceCache::Private
+{
+  public:
+    Private(KFilePlacesDeviceCache *parent):
+      queryRunning(false),
+      q(parent)
+    { }
+
+    ~Private()
+    { }
+
+    /* This method runs asynchronously in thread */
+    QSet<QString> listSolidDevicesAsync()
+    {
+        QSet<QString> udis;
+
+        kDebug() << "Querying Solid devices...";
+        const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(solidPredicate);
+        kDebug() << "Retrieved" << deviceList.count() << "devices";
+
+        Q_FOREACH (const Solid::Device& device, deviceList) {
+            if (solidPredicate.matches(device)) {
+                udis << device.udi();
+            }
+        }
+
+        return udis;
+    }
+
+    void _k_slotDeviceAdded(const QString &udi)
+    {
+        devicesCache << udi;
+
+        Q_EMIT q->deviceAdded(udi);
+    }
+
+    void _k_slotDeviceRemoved(const QString &udi)
+    {
+        if (!devicesCache.contains(udi)) {
+            return;
+        }
+
+        devicesCache.remove(udi);
+
+        Q_EMIT q->deviceRemoved(udi);
+    }
+
+    void _k_listSolidDevicesFinished()
+    {
+        Q_FOREACH (const QString& device, futureWatcher->result()) {
+            _k_slotDeviceAdded(device);
+        }
+
+        delete futureWatcher;
+        futureWatcher = 0;
+
+        queryRunning = false;
+    }
+
+    Solid::Predicate solidPredicate;
+
+    QFutureWatcher< QSet<QString> >* futureWatcher;
+
+    /* Static */
+    QSet<QString> devicesCache;
+    bool queryRunning;
+
+    KFilePlacesDeviceCache *q;
+};
+
+KFilePlacesDeviceCache::KFilePlacesDeviceCache():
+    QObject(),
+    d(new Private(this))
+{
+    Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
+    connect(notifier, SIGNAL(deviceAdded(QString)), this, SLOT(_k_slotDeviceAdded(QString)));
+    connect(notifier, SIGNAL(deviceRemoved(QString)), this, SLOT(_k_slotDeviceRemoved(QString)));
+
+    QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
+        " OR "
+        "[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
+        " OR "
+        "OpticalDisc.availableContent & 'Audio' ]"
+        " OR "
+        "StorageAccess.ignored == false ]");
+
+    if (KProtocolInfo::isKnownProtocol("mtp")) {
+        predicate.prepend("[");
+        predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
+    }
+
+    d->solidPredicate = Solid::Predicate::fromString(predicate);
+}
+
+KFilePlacesDeviceCache* KFilePlacesDeviceCache::self()
+{
+    static QMutex mutex;
+
+    mutex.lock();
+    if (s_instance == 0) {
+        s_instance = new KFilePlacesDeviceCache();
+    }
+    mutex.unlock();
+
+    return s_instance;
+}
+
+KFilePlacesDeviceCache::~KFilePlacesDeviceCache()
+{
+    Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
+    disconnect(notifier, SIGNAL(deviceAdded(QString)));
+    disconnect(notifier, SIGNAL(deviceRemoved(QString)));
+
+    delete d;
+}
+
+const Solid::Predicate& KFilePlacesDeviceCache::predicate() const
+{
+    return d->solidPredicate;
+}
+
+const QSet<QString>& KFilePlacesDeviceCache::devices() const
+{
+    kDebug();
+    if (d->devicesCache.isEmpty() && !d->queryRunning) {
+          d->queryRunning = true;
+          d->futureWatcher = new QFutureWatcher< QSet<QString> >;
+          connect(d->futureWatcher, SIGNAL(finished()), this, SLOT(_k_listSolidDevicesFinished()));
+
+          QFuture< QSet<QString> > future = QtConcurrent::run(d, &Private::listSolidDevicesAsync);
+          d->futureWatcher->setFuture(future);
+    }
+
+    return d->devicesCache;
+}
+
+
+
+#include "kfileplacesdevicecache.moc"
diff --git a/kfile/kfileplacesdevicecache.h b/kfile/kfileplacesdevicecache.h
new file mode 100644
index 0000000..7293d03
--- /dev/null
+++ b/kfile/kfileplacesdevicecache.h
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2012 Dan Vrátil <dvratil@redhat.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License version 2 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public License
+  along with this library; see the file COPYING.LIB.  If not, write to
+  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+  Boston, MA 02110-1301, USA.
+*/
+
+#ifndef KFILEPLACESDEVICECACHE_H
+#define KFILEPLACESDEVICECACHE_H
+
+#include <kfile_export.h>
+
+#include <QObject>
+#include <QSet>
+
+#include <solid/predicate.h>
+
+/**
+ * @short Asynchronous cache for Solid devices
+ *
+ * Purpose of this cache is to load Solid devices asynchronously, because
+ * udisks2 backend can take quite a lot of time to enumerate devices, and
+ * since Solid does not have async API, the UI thread is blocked for too long.
+ *
+ * When libsolid2 with asynchronous API is available, this class can go away.
+ *
+ * The cache keeps itself up-to-date and notifies listeners when a
+ * new devices is added or removed.
+ */
+class KFILE_EXPORT KFilePlacesDeviceCache : public QObject
+{
+    Q_OBJECT
+
+public:
+    /**
+     * Returns a global instance of the cache
+     */
+    static KFilePlacesDeviceCache* self();
+
+    /**
+     * Returns list of Solid devices.
+     *
+     * This method always returns immediatelly. When there are no
+     * devices in the cache, it returns an empty list and will asynchronously
+     * query Solid for devices and will notify listeners by emitting
+     * deviceAdded() signal for each devices loaded.
+     */
+    const QSet<QString>& devices() const;
+
+    /**
+     * Returns Solid::Predicate used to obtain devices from Solid
+     */
+    const Solid::Predicate& predicate() const;
+
+Q_SIGNALS:
+    /**
+     * Emitted whenever a new device is discovered.
+     *
+     * @param udi UDI (Universal Device ID) of the newly discovered device
+     */
+    void deviceAdded(const QString& udi);
+
+    /**
+     * Emitted whenever a device is removed from system
+     *
+     * @param udi UDI (Universal Device ID) of the removed device
+     */
+    void deviceRemoved(const QString& udi);
+
+private:
+    Q_PRIVATE_SLOT(d, void _k_listSolidDevicesFinished())
+    Q_PRIVATE_SLOT(d, void _k_slotDeviceAdded(const QString&))
+    Q_PRIVATE_SLOT(d, void _k_slotDeviceRemoved(const QString&))
+
+    class Private;
+    Private * const d;
+    friend class Private;
+
+    explicit KFilePlacesDeviceCache();
+    virtual ~KFilePlacesDeviceCache();
+
+    static KFilePlacesDeviceCache* s_instance;
+};
+
+#endif // KFILEPLACESDEVICECACHE_H
diff --git a/kfile/kfileplacesmodel.cpp b/kfile/kfileplacesmodel.cpp
index 0192926..e0b01c6 100644
--- a/kfile/kfileplacesmodel.cpp
+++ b/kfile/kfileplacesmodel.cpp
@@ -20,6 +20,7 @@
 #include "kfileplacesmodel.h"
 #include "kfileplacesitem_p.h"
 #include "kfileplacessharedbookmarks_p.h"
+#include "kfileplacesdevicecache.h"
 
 #ifdef _WIN32_WCE
 #include "Windows.h"
@@ -49,14 +50,12 @@
 #include <kio/netaccess.h>
 #include <kprotocolinfo.h>
 
-#include <solid/devicenotifier.h>
 #include <solid/storageaccess.h>
 #include <solid/storagedrive.h>
 #include <solid/storagevolume.h>
 #include <solid/opticaldrive.h>
 #include <solid/opticaldisc.h>
 #include <solid/portablemediaplayer.h>
-#include <solid/predicate.h>
 
 class KFilePlacesModel::Private
 {
@@ -74,7 +73,6 @@ public:
     QSet<QString> availableDevices;
     QMap<QObject*, QPersistentModelIndex> setupInProgress;
 
-    Solid::Predicate predicate;
     KBookmarkManager *bookmarkManager;
     KFilePlacesSharedBookmarks * sharedBookmarks;
 
@@ -149,30 +147,12 @@ KFilePlacesModel::KFilePlacesModel(QObject *parent)
     // create after, so if we have own places, they are added afterwards, in case of equal priorities
     d->sharedBookmarks = new KFilePlacesSharedBookmarks(d->bookmarkManager);
 
-    QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
-        " OR "
-        "[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
-        " OR "
-        "OpticalDisc.availableContent & 'Audio' ]"
-        " OR "
-        "StorageAccess.ignored == false ]");
-
-    if (KProtocolInfo::isKnownProtocol("mtp")) {
-        predicate.prepend("[");
-        predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
-    }
-
-    d->predicate = Solid::Predicate::fromString(predicate);
-
-    Q_ASSERT(d->predicate.isValid());
-
     connect(d->bookmarkManager, SIGNAL(changed(QString,QString)),
             this, SLOT(_k_reloadBookmarks()));
     connect(d->bookmarkManager, SIGNAL(bookmarksChanged(QString)),
             this, SLOT(_k_reloadBookmarks()));
 
-    d->_k_reloadBookmarks();
-    QTimer::singleShot(0, this, SLOT(_k_initDeviceList()));
+    d->_k_initDeviceList();
 }
 
 KFilePlacesModel::~KFilePlacesModel()
@@ -313,30 +293,21 @@ QModelIndex KFilePlacesModel::closestItem(const KUrl &url) const
 
 void KFilePlacesModel::Private::_k_initDeviceList()
 {
-    Solid::DeviceNotifier *notifier = Solid::DeviceNotifier::instance();
-
-    connect(notifier, SIGNAL(deviceAdded(QString)),
+    KFilePlacesDeviceCache *cache = KFilePlacesDeviceCache::self();
+    connect(cache, SIGNAL(deviceAdded(QString)),
             q, SLOT(_k_deviceAdded(QString)));
-    connect(notifier, SIGNAL(deviceRemoved(QString)),
+    connect(cache, SIGNAL(deviceRemoved(QString)),
             q, SLOT(_k_deviceRemoved(QString)));
 
-    const QList<Solid::Device> &deviceList = Solid::Device::listFromQuery(predicate);
-
-    foreach(const Solid::Device &device, deviceList) {
-        availableDevices << device.udi();
-    }
+    availableDevices = cache->devices();
 
     _k_reloadBookmarks();
 }
 
 void KFilePlacesModel::Private::_k_deviceAdded(const QString &udi)
 {
-    Solid::Device d(udi);
-
-    if (predicate.matches(d)) {
-        availableDevices << udi;
-        _k_reloadBookmarks();
-    }
+    availableDevices << udi;
+    _k_reloadBookmarks();
 }
 
 void KFilePlacesModel::Private::_k_deviceRemoved(const QString &udi)
1	diff --git a/kfile/CMakeLists.txt b/kfile/CMakeLists.txt
2	index ceae140..c7c4d3d 100644
3	--- a/kfile/CMakeLists.txt
4	+++ b/kfile/CMakeLists.txt
5	@@ -20,6 +20,7 @@ set(kfile_LIB_SRCS
6	kfilefiltercombo.cpp
7	kfiletreeview.cpp
8	kfilewidget.cpp
9	+ kfileplacesdevicecache.cpp
10	kfileplacesitem.cpp
11	kfileplacesmodel.cpp
12	kfileplacessharedbookmarks.cpp
13	@@ -63,6 +64,7 @@ install( FILES
14	kdirselectdialog.h
15	kdirsortfilterproxymodel.h
16	kfilefiltercombo.h
17	+ kfileplacesdevicecache.h
18	kfileplacesmodel.h
19	kfileplacesview.h
20	kfilepreviewgenerator.h
21	diff --git a/kfile/kfileplacesdevicecache.cpp b/kfile/kfileplacesdevicecache.cpp
22	new file mode 100644
23	index 0000000..40f7242
24	--- /dev/null
25	+++ b/kfile/kfileplacesdevicecache.cpp
26	@@ -0,0 +1,174 @@
27	+/*
28	+ Copyright (C) 2012 Dan Vrátil <dvratil@redhat.com>
29	+
30	+ This library is free software; you can redistribute it and/or
31	+ modify it under the terms of the GNU Library General Public
32	+ License version 2 as published by the Free Software Foundation.
33	+
34	+ This library is distributed in the hope that it will be useful,
35	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
36	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
37	+ Library General Public License for more details.
38	+
39	+ You should have received a copy of the GNU Library General Public License
40	+ along with this library; see the file COPYING.LIB. If not, write to
41	+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
42	+ Boston, MA 02110-1301, USA.
43	+*/
44	+
45	+#include "kfileplacesdevicecache.h"
46	+
47	+#include <QMutex>
48	+#include <QtConcurrentRun>
49	+#include <QFutureWatcher>
50	+#include <QTimer>
51	+
52	+#include <kprotocolinfo.h>
53	+#include <solid/predicate.h>
54	+#include <solid/device.h>
55	+#include <solid/devicenotifier.h>
56	+#include <solid/genericinterface.h>
57	+
58	+#include <kdebug.h>
59	+
60	+KFilePlacesDeviceCache* KFilePlacesDeviceCache::s_instance = 0;
61	+
62	+class KFilePlacesDeviceCache::Private
63	+{
64	+ public:
65	+ Private(KFilePlacesDeviceCache *parent):
66	+ queryRunning(false),
67	+ q(parent)
68	+ { }
69	+
70	+ ~Private()
71	+ { }
72	+
73	+ /* This method runs asynchronously in thread */
74	+ QSet<QString> listSolidDevicesAsync()
75	+ {
76	+ QSet<QString> udis;
77	+
78	+ kDebug() << "Querying Solid devices...";
79	+ const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(solidPredicate);
80	+ kDebug() << "Retrieved" << deviceList.count() << "devices";
81	+
82	+ Q_FOREACH (const Solid::Device& device, deviceList) {
83	+ if (solidPredicate.matches(device)) {
84	+ udis << device.udi();
85	+ }
86	+ }
87	+
88	+ return udis;
89	+ }
90	+
91	+ void _k_slotDeviceAdded(const QString &udi)
92	+ {
93	+ devicesCache << udi;
94	+
95	+ Q_EMIT q->deviceAdded(udi);
96	+ }
97	+
98	+ void _k_slotDeviceRemoved(const QString &udi)
99	+ {
100	+ if (!devicesCache.contains(udi)) {
101	+ return;
102	+ }
103	+
104	+ devicesCache.remove(udi);
105	+
106	+ Q_EMIT q->deviceRemoved(udi);
107	+ }
108	+
109	+ void _k_listSolidDevicesFinished()
110	+ {
111	+ Q_FOREACH (const QString& device, futureWatcher->result()) {
112	+ _k_slotDeviceAdded(device);
113	+ }
114	+
115	+ delete futureWatcher;
116	+ futureWatcher = 0;
117	+
118	+ queryRunning = false;
119	+ }
120	+
121	+ Solid::Predicate solidPredicate;
122	+
123	+ QFutureWatcher< QSet<QString> >* futureWatcher;
124	+
125	+ /* Static */
126	+ QSet<QString> devicesCache;
127	+ bool queryRunning;
128	+
129	+ KFilePlacesDeviceCache *q;
130	+};
131	+
132	+KFilePlacesDeviceCache::KFilePlacesDeviceCache():
133	+ QObject(),
134	+ d(new Private(this))
135	+{
136	+ Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
137	+ connect(notifier, SIGNAL(deviceAdded(QString)), this, SLOT(_k_slotDeviceAdded(QString)));
138	+ connect(notifier, SIGNAL(deviceRemoved(QString)), this, SLOT(_k_slotDeviceRemoved(QString)));
139	+
140	+ QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
141	+ " OR "
142	+ "[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
143	+ " OR "
144	+ "OpticalDisc.availableContent & 'Audio' ]"
145	+ " OR "
146	+ "StorageAccess.ignored == false ]");
147	+
148	+ if (KProtocolInfo::isKnownProtocol("mtp")) {
149	+ predicate.prepend("[");
150	+ predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
151	+ }
152	+
153	+ d->solidPredicate = Solid::Predicate::fromString(predicate);
154	+}
155	+
156	+KFilePlacesDeviceCache* KFilePlacesDeviceCache::self()
157	+{
158	+ static QMutex mutex;
159	+
160	+ mutex.lock();
161	+ if (s_instance == 0) {
162	+ s_instance = new KFilePlacesDeviceCache();
163	+ }
164	+ mutex.unlock();
165	+
166	+ return s_instance;
167	+}
168	+
169	+KFilePlacesDeviceCache::~KFilePlacesDeviceCache()
170	+{
171	+ Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
172	+ disconnect(notifier, SIGNAL(deviceAdded(QString)));
173	+ disconnect(notifier, SIGNAL(deviceRemoved(QString)));
174	+
175	+ delete d;
176	+}
177	+
178	+const Solid::Predicate& KFilePlacesDeviceCache::predicate() const
179	+{
180	+ return d->solidPredicate;
181	+}
182	+
183	+const QSet<QString>& KFilePlacesDeviceCache::devices() const
184	+{
185	+ kDebug();
186	+ if (d->devicesCache.isEmpty() && !d->queryRunning) {
187	+ d->queryRunning = true;
188	+ d->futureWatcher = new QFutureWatcher< QSet<QString> >;
189	+ connect(d->futureWatcher, SIGNAL(finished()), this, SLOT(_k_listSolidDevicesFinished()));
190	+
191	+ QFuture< QSet<QString> > future = QtConcurrent::run(d, &Private::listSolidDevicesAsync);
192	+ d->futureWatcher->setFuture(future);
193	+ }
194	+
195	+ return d->devicesCache;
196	+}
197	+
198	+
199	+
200	+#include "kfileplacesdevicecache.moc"
201	diff --git a/kfile/kfileplacesdevicecache.h b/kfile/kfileplacesdevicecache.h
202	new file mode 100644
203	index 0000000..7293d03
204	--- /dev/null
205	+++ b/kfile/kfileplacesdevicecache.h
206	@@ -0,0 +1,96 @@
207	+/*
208	+ Copyright (C) 2012 Dan Vrátil <dvratil@redhat.com>
209	+
210	+ This library is free software; you can redistribute it and/or
211	+ modify it under the terms of the GNU Library General Public
212	+ License version 2 as published by the Free Software Foundation.
213	+
214	+ This library is distributed in the hope that it will be useful,
215	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
216	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
217	+ Library General Public License for more details.
218	+
219	+ You should have received a copy of the GNU Library General Public License
220	+ along with this library; see the file COPYING.LIB. If not, write to
221	+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
222	+ Boston, MA 02110-1301, USA.
223	+*/
224	+
225	+#ifndef KFILEPLACESDEVICECACHE_H
226	+#define KFILEPLACESDEVICECACHE_H
227	+
228	+#include <kfile_export.h>
229	+
230	+#include <QObject>
231	+#include <QSet>
232	+
233	+#include <solid/predicate.h>
234	+
235	+/**
236	+ * @short Asynchronous cache for Solid devices
237	+ *
238	+ * Purpose of this cache is to load Solid devices asynchronously, because
239	+ * udisks2 backend can take quite a lot of time to enumerate devices, and
240	+ * since Solid does not have async API, the UI thread is blocked for too long.
241	+ *
242	+ * When libsolid2 with asynchronous API is available, this class can go away.
243	+ *
244	+ * The cache keeps itself up-to-date and notifies listeners when a
245	+ * new devices is added or removed.
246	+ */
247	+class KFILE_EXPORT KFilePlacesDeviceCache : public QObject
248	+{
249	+ Q_OBJECT
250	+
251	+public:
252	+ /**
253	+ * Returns a global instance of the cache
254	+ */
255	+ static KFilePlacesDeviceCache* self();
256	+
257	+ /**
258	+ * Returns list of Solid devices.
259	+ *
260	+ * This method always returns immediatelly. When there are no
261	+ * devices in the cache, it returns an empty list and will asynchronously
262	+ * query Solid for devices and will notify listeners by emitting
263	+ * deviceAdded() signal for each devices loaded.
264	+ */
265	+ const QSet<QString>& devices() const;
266	+
267	+ /**
268	+ * Returns Solid::Predicate used to obtain devices from Solid
269	+ */
270	+ const Solid::Predicate& predicate() const;
271	+
272	+Q_SIGNALS:
273	+ /**
274	+ * Emitted whenever a new device is discovered.
275	+ *
276	+ * @param udi UDI (Universal Device ID) of the newly discovered device
277	+ */
278	+ void deviceAdded(const QString& udi);
279	+
280	+ /**
281	+ * Emitted whenever a device is removed from system
282	+ *
283	+ * @param udi UDI (Universal Device ID) of the removed device
284	+ */
285	+ void deviceRemoved(const QString& udi);
286	+
287	+private:
288	+ Q_PRIVATE_SLOT(d, void _k_listSolidDevicesFinished())
289	+ Q_PRIVATE_SLOT(d, void _k_slotDeviceAdded(const QString&))
290	+ Q_PRIVATE_SLOT(d, void _k_slotDeviceRemoved(const QString&))
291	+
292	+ class Private;
293	+ Private * const d;
294	+ friend class Private;
295	+
296	+ explicit KFilePlacesDeviceCache();
297	+ virtual ~KFilePlacesDeviceCache();
298	+
299	+ static KFilePlacesDeviceCache* s_instance;
300	+};
301	+
302	+#endif // KFILEPLACESDEVICECACHE_H
303	diff --git a/kfile/kfileplacesmodel.cpp b/kfile/kfileplacesmodel.cpp
304	index 0192926..e0b01c6 100644
305	--- a/kfile/kfileplacesmodel.cpp
306	+++ b/kfile/kfileplacesmodel.cpp
307	@@ -20,6 +20,7 @@
308	#include "kfileplacesmodel.h"
309	#include "kfileplacesitem_p.h"
310	#include "kfileplacessharedbookmarks_p.h"
311	+#include "kfileplacesdevicecache.h"
312
313	#ifdef _WIN32_WCE
314	#include "Windows.h"
315	@@ -49,14 +50,12 @@
316	#include <kio/netaccess.h>
317	#include <kprotocolinfo.h>
318
319	-#include <solid/devicenotifier.h>
320	#include <solid/storageaccess.h>
321	#include <solid/storagedrive.h>
322	#include <solid/storagevolume.h>
323	#include <solid/opticaldrive.h>
324	#include <solid/opticaldisc.h>
325	#include <solid/portablemediaplayer.h>
326	-#include <solid/predicate.h>
327
328	class KFilePlacesModel::Private
329	{
330	@@ -74,7 +73,6 @@ public:
331	QSet<QString> availableDevices;
332	QMap<QObject*, QPersistentModelIndex> setupInProgress;
333
334	- Solid::Predicate predicate;
335	KBookmarkManager *bookmarkManager;
336	KFilePlacesSharedBookmarks * sharedBookmarks;
337
338	@@ -149,30 +147,12 @@ KFilePlacesModel::KFilePlacesModel(QObject *parent)
339	// create after, so if we have own places, they are added afterwards, in case of equal priorities
340	d->sharedBookmarks = new KFilePlacesSharedBookmarks(d->bookmarkManager);
341
342	- QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
343	- " OR "
344	- "[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
345	- " OR "
346	- "OpticalDisc.availableContent & 'Audio' ]"
347	- " OR "
348	- "StorageAccess.ignored == false ]");
349	-
350	- if (KProtocolInfo::isKnownProtocol("mtp")) {
351	- predicate.prepend("[");
352	- predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
353	- }
354	-
355	- d->predicate = Solid::Predicate::fromString(predicate);
356	-
357	- Q_ASSERT(d->predicate.isValid());
358	-
359	connect(d->bookmarkManager, SIGNAL(changed(QString,QString)),
360	this, SLOT(_k_reloadBookmarks()));
361	connect(d->bookmarkManager, SIGNAL(bookmarksChanged(QString)),
362	this, SLOT(_k_reloadBookmarks()));
363
364	- d->_k_reloadBookmarks();
365	- QTimer::singleShot(0, this, SLOT(_k_initDeviceList()));
366	+ d->_k_initDeviceList();
367	}
368
369	KFilePlacesModel::~KFilePlacesModel()
370	@@ -313,30 +293,21 @@ QModelIndex KFilePlacesModel::closestItem(const KUrl &url) const
371
372	void KFilePlacesModel::Private::_k_initDeviceList()
373	{
374	- Solid::DeviceNotifier *notifier = Solid::DeviceNotifier::instance();
375	-
376	- connect(notifier, SIGNAL(deviceAdded(QString)),
377	+ KFilePlacesDeviceCache *cache = KFilePlacesDeviceCache::self();
378	+ connect(cache, SIGNAL(deviceAdded(QString)),
379	q, SLOT(_k_deviceAdded(QString)));
380	- connect(notifier, SIGNAL(deviceRemoved(QString)),
381	+ connect(cache, SIGNAL(deviceRemoved(QString)),
382	q, SLOT(_k_deviceRemoved(QString)));
383
384	- const QList<Solid::Device> &deviceList = Solid::Device::listFromQuery(predicate);
385	-
386	- foreach(const Solid::Device &device, deviceList) {
387	- availableDevices << device.udi();
388	- }
389	+ availableDevices = cache->devices();
390
391	_k_reloadBookmarks();
392	}
393
394	void KFilePlacesModel::Private::_k_deviceAdded(const QString &udi)
395	{
396	- Solid::Device d(udi);
397	-
398	- if (predicate.matches(d)) {
399	- availableDevices << udi;
400	- _k_reloadBookmarks();
401	- }
402	+ availableDevices << udi;
403	+ _k_reloadBookmarks();
404	}
405
406	void KFilePlacesModel::Private::_k_deviceRemoved(const QString &udi)