diff --git a/kio/kiokdeconnect.cpp b/kio/kiokdeconnect.cpp
index 0bf62a84..7e9f6c99 100644
--- a/kio/kiokdeconnect.cpp
+++ b/kio/kiokdeconnect.cpp
@@ -1,246 +1,246 @@
 /**
  * Copyright 2013 Albert Vaca <albertvaka@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
 #include "kiokdeconnect.h"
 
 #include <QThread>
 #include <QDBusMetaType>
 
 #include <KLocalizedString>
 
 #include <QDebug>
 #include <QtPlugin>
 
 Q_LOGGING_CATEGORY(KDECONNECT_KIO, "kdeconnect.kio")
 
 class KIOPluginForMetaData : public QObject
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.kde.kio.slave.kdeconnect" FILE "kdeconnect.json")
 };
 
 extern "C" int Q_DECL_EXPORT kdemain(int argc, char** argv)
 {
     QCoreApplication app(argc, argv);
     app.setApplicationName(QStringLiteral("kio_kdeconnect"));
     
     if (argc != 4) {
         fprintf(stderr, "Usage: kio_kdeconnect protocol pool app\n");
         exit(-1);
     }
 
     KioKdeconnect slave(argv[2], argv[3]);
     slave.dispatchLoop();
     return 0;
 }
 
 //Some useful error mapping
 KIO::Error toKioError(const QDBusError::ErrorType type)
 {
     switch (type) 
     {
         case QDBusError::NoError:
             return KIO::Error(KJob::NoError);
         case QDBusError::NoMemory:
             return KIO::ERR_OUT_OF_MEMORY;
         case QDBusError::Timeout:          
             return KIO::ERR_SERVER_TIMEOUT;
         case QDBusError::TimedOut:          
             return KIO::ERR_SERVER_TIMEOUT;
         default:
             return KIO::ERR_INTERNAL;
     };
 };
 
 template <typename T>
 bool handleDBusError(QDBusReply<T>& reply, KIO::SlaveBase* slave)
 {
     if (!reply.isValid())
     {
         qCDebug(KDECONNECT_KIO) << "Error in DBus request:" << reply.error();
         slave->error(toKioError(reply.error().type()),reply.error().message());
         return true;
     }
     return false;
 }
 
 KioKdeconnect::KioKdeconnect(const QByteArray& pool, const QByteArray& app)
     : SlaveBase("kdeconnect", pool, app),
     m_dbusInterface(new DaemonDbusInterface(this))
 {
 
 }
 
 void KioKdeconnect::listAllDevices()
 {
     infoMessage(i18n("Listing devices..."));
 
     //TODO: Change to all devices and show different icons for connected and disconnected?
     const QStringList devices = m_dbusInterface->devices(true, true);
 
     for (const QString& deviceId : devices) {
 
         DeviceDbusInterface interface(deviceId);
 
         if (!interface.hasPlugin(QStringLiteral("kdeconnect_sftp"))) continue;
 
         const QString path = QStringLiteral("kdeconnect://").append(deviceId).append("/");
         const QString name = interface.name();
         const QString icon = QStringLiteral("kdeconnect");
 
         KIO::UDSEntry entry;
         entry.insert(KIO::UDSEntry::UDS_NAME, name);
         entry.insert(KIO::UDSEntry::UDS_ICON_NAME, icon);
         entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
         entry.insert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
         entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, QLatin1String(""));
         entry.insert(KIO::UDSEntry::UDS_URL, path);
         listEntry(entry);
     }
 
     // We also need a non-null and writable UDSentry for "."
     KIO::UDSEntry entry;
     entry.insert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     entry.insert(KIO::UDSEntry::UDS_SIZE, 0);
     entry.insert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH);
     listEntry(entry);
 
     infoMessage(QLatin1String(""));
     finished();
 }
 
 void KioKdeconnect::listDevice()
 {
     infoMessage(i18n("Accessing device..."));
 
     qCDebug(KDECONNECT_KIO) << "ListDevice" << m_currentDevice;
 
     SftpDbusInterface interface(m_currentDevice);
 
     QDBusReply<bool> mountreply = interface.mountAndWait();
 
     if (handleDBusError(mountreply, this)) {
         return;
     }
 
     if (!mountreply.value()) {
         error(KIO::ERR_COULD_NOT_MOUNT, i18n("Could not mount device filesystem"));
         return;
     }
 
     QDBusReply< QVariantMap > urlreply = interface.getDirectories();
 
     if (handleDBusError(urlreply, this)) {
         return;
     }
 
     QVariantMap urls = urlreply.value();
 
     for (QVariantMap::iterator it = urls.begin(); it != urls.end(); ++it) {
 
         const QString path = it.key();
         const QString name = it.value().toString();
         const QString icon = QStringLiteral("folder");
 
         KIO::UDSEntry entry;
-        entry.insert(KIO::UDSEntry::UDS_NAME, QStringLiteral("files"));
-        entry.insert(KIO::UDSEntry::UDS_DISPLAY_NAME, name);
+        entry.insert(KIO::UDSEntry::UDS_NAME, name);
         entry.insert(KIO::UDSEntry::UDS_ICON_NAME, icon);
         entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
         entry.insert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
         entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, QLatin1String(""));
         entry.insert(KIO::UDSEntry::UDS_URL, QUrl::fromLocalFile(path).toString());
         listEntry(entry);
     }
 
     // We also need a non-null and writable UDSentry for "."
     KIO::UDSEntry entry;
     entry.insert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     entry.insert(KIO::UDSEntry::UDS_SIZE, 0);
     entry.insert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH);
+
     listEntry(entry);
 
     infoMessage(QLatin1String(""));
     finished();
 
 }
 
 
 
 void KioKdeconnect::listDir(const QUrl& url)
 {
     qCDebug(KDECONNECT_KIO) << "Listing..." << url;
 
     /// Url is not used here because all we could care about the url is the host, and that's already
     /// handled in @p setHost
     Q_UNUSED(url);
 
     if (!m_dbusInterface->isValid()) {
         infoMessage(i18n("Could not contact background service."));
         finished();
         return;
     }
 
     if (m_currentDevice.isEmpty()) {
         listAllDevices();
     } else {
         listDevice();
     }
 }
 
 void KioKdeconnect::stat(const QUrl& url)
 {
     qCDebug(KDECONNECT_KIO) << "Stat: " << url;
 
     KIO::UDSEntry entry;
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     statEntry(entry);
 
     finished();
 }
 
 void KioKdeconnect::get(const QUrl& url)
 {
     qCDebug(KDECONNECT_KIO) << "Get: " << url;
     mimeType(QLatin1String(""));
     finished();
 }
 
 void KioKdeconnect::setHost(const QString& hostName, quint16 port, const QString& user, const QString& pass)
 {
 
     //This is called before everything else to set the file we want to show
 
     qCDebug(KDECONNECT_KIO) << "Setting host: " << hostName;
 
     // In this kio only the hostname is used
     Q_UNUSED(port)
     Q_UNUSED(user)
     Q_UNUSED(pass)
 
     m_currentDevice = hostName;
 
 }
 
 //needed for JSON file embedding
 #include "kiokdeconnect.moc"
diff --git a/plugins/sftp/sftpplugin.cpp b/plugins/sftp/sftpplugin.cpp
index 3a071f39..7ab6e5ea 100644
--- a/plugins/sftp/sftpplugin.cpp
+++ b/plugins/sftp/sftpplugin.cpp
@@ -1,192 +1,193 @@
 /**
  * Copyright 2014 Samoilenko Yuri<kinnalru@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "sftpplugin.h"
 
 #include <QDBusConnection>
 #include <QDir>
 #include <QDebug>
 #include <QStandardPaths>
 
 #include <KLocalizedString>
 #include <KNotification>
 #include <KRun>
 #include <KFilePlacesModel>
 #include <KPluginFactory>
 
 #include "mounter.h"
 #include "sftp_debug.h"
 
 K_PLUGIN_FACTORY_WITH_JSON( KdeConnectPluginFactory, "kdeconnect_sftp.json", registerPlugin< SftpPlugin >(); )
 
 Q_LOGGING_CATEGORY(KDECONNECT_PLUGIN_SFTP, "kdeconnect.plugin.sftp")
 
 static const QSet<QString> fields_c = QSet<QString>() << QStringLiteral("ip") << QStringLiteral("port") << QStringLiteral("user") << QStringLiteral("port") << QStringLiteral("path");
 
 struct SftpPlugin::Pimpl
 {
     Pimpl() : m_mounter(nullptr) {}
   
     //Add KIO entry to Dolphin's Places
     KFilePlacesModel  m_placesModel;
     Mounter* m_mounter;
 };
 
 SftpPlugin::SftpPlugin(QObject* parent, const QVariantList& args)
     : KdeConnectPlugin(parent, args)
     , d(new Pimpl())
 { 
     deviceId = device()->id();
     addToDolphin();
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Created device:" << device()->name();
 }
 
 SftpPlugin::~SftpPlugin()
 {
     QDBusConnection::sessionBus().unregisterObject(dbusPath(), QDBusConnection::UnregisterTree);
     removeFromDolphin();    
     unmount();
 }
 
 void SftpPlugin::addToDolphin()
 {
     removeFromDolphin();
+    
     QUrl kioUrl("kdeconnect://"+deviceId+"/");
     d->m_placesModel.addPlace(device()->name(), kioUrl, QStringLiteral("kdeconnect"));
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "add to dolphin";
 }
 
 void SftpPlugin::removeFromDolphin()
 {
     QUrl kioUrl("kdeconnect://"+deviceId+"/");
     QModelIndex index = d->m_placesModel.closestItem(kioUrl);
     while (index.row() != -1) {
         d->m_placesModel.removePlace(index);
         index = d->m_placesModel.closestItem(kioUrl);
     }
 }
 
 void SftpPlugin::mount()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Mount device:" << device()->name();
     if (d->m_mounter) {
         return;
     }
 
     d->m_mounter = new Mounter(this);
     connect(d->m_mounter, &Mounter::mounted, this, &SftpPlugin::onMounted);
     connect(d->m_mounter, &Mounter::unmounted, this, &SftpPlugin::onUnmounted);
     connect(d->m_mounter, &Mounter::failed, this, &SftpPlugin::onFailed);
 }
 
 void SftpPlugin::unmount()
 {
     if (d->m_mounter)
     {
         d->m_mounter->deleteLater();
         d->m_mounter = nullptr;
     }
 }
 
 bool SftpPlugin::mountAndWait()
 {
     mount();
     return d->m_mounter->wait();
 }
 
 bool SftpPlugin::isMounted() const
 {
     return d->m_mounter && d->m_mounter->isMounted();
 }
 
 bool SftpPlugin::startBrowsing()
 {
     if (mountAndWait()) {
         //return new KRun(QUrl::fromLocalFile(mountPoint()), 0);
         return new KRun(QUrl("kdeconnect://"+deviceId), nullptr);
     }
     return false;
 }
 
 bool SftpPlugin::receivePacket(const NetworkPacket& np)
 {
     if (!(fields_c - np.body().keys().toSet()).isEmpty()) {
         // packet is invalid
         return false;
     }
     
     Q_EMIT packetReceived(np);
 
     remoteDirectories.clear();
     if (np.has(QStringLiteral("multiPaths"))) {
         QStringList paths = np.get<QStringList>(QStringLiteral("multiPaths"),QStringList());
         QStringList names = np.get<QStringList>(QStringLiteral("pathNames"),QStringList());
         int size = qMin<int>(names.size(), paths.size());
         for (int i = 0; i < size; i++) {
             remoteDirectories.insert(mountPoint() + paths.at(i), names.at(i));
         }
     } else {
         remoteDirectories.insert(mountPoint(), i18n("All files"));
         remoteDirectories.insert(mountPoint() + "/DCIM/Camera", i18n("Camera pictures"));
     }
 
     return true;
 }
 
 QString SftpPlugin::mountPoint()
 {
     QString runtimePath = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
     if (runtimePath.isEmpty()) {
         runtimePath = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
     }
     return QDir(runtimePath).absoluteFilePath(deviceId);
 }
 
 void SftpPlugin::onMounted()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << device()->name() << QStringLiteral("Remote filesystem mounted at %1").arg(mountPoint());
 
     Q_EMIT mounted();
 }
 
 void SftpPlugin::onUnmounted()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << device()->name() << "Remote filesystem unmounted";
 
     unmount();
     
     Q_EMIT unmounted();
 }
 
 void SftpPlugin::onFailed(const QString& message)
 {
     KNotification::event(KNotification::Error, device()->name(), message);
 
     unmount();
 
     Q_EMIT unmounted();
 }
 
 QVariantMap SftpPlugin::getDirectories()
 {
     return remoteDirectories;
 }
 
 #include "sftpplugin.moc"