diff --git a/CMakeLists.txt b/CMakeLists.txt
index 12010260..0d036e1d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,66 +1,66 @@
 project(kdeconnect)
 
 set(KDECONNECT_VERSION_MAJOR 1)
 set(KDECONNECT_VERSION_MINOR 1)
 set(KDECONNECT_VERSION_PATCH 0)
 set(KDECONNECT_VERSION "${KDECONNECT_VERSION_MAJOR}.${KDECONNECT_VERSION_MINOR}.${KDECONNECT_VERSION_PATCH}")
 
 cmake_minimum_required(VERSION 2.8.12)
 
 find_package(ECM 0.0.9 REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_SOURCE_DIR}/cmake)
 
-find_package(Qt5 5.2 REQUIRED COMPONENTS Quick Bluetooth)
+find_package(Qt5 5.2 REQUIRED COMPONENTS Quick)
 
 find_package(KF5 REQUIRED COMPONENTS I18n ConfigWidgets DBusAddons)
 find_package(KF5DocTools)
 find_package(Qca-qt5 2.1.0 REQUIRED)
 
 include_directories(${CMAKE_SOURCE_DIR})
 
 configure_file(kdeconnect-version.h.in ${CMAKE_CURRENT_BINARY_DIR}/kdeconnect-version.h)
 
 include(KDEInstallDirs)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
 include(ECMAddTests)
 include(ECMSetupVersion)
 include(ECMInstallIcons)
 include(FeatureSummary)
 
 include(KDEConnectMacros.cmake)
 
 add_definitions(-DQT_NO_URL_CAST_FROM_STRING -DQT_NO_KEYWORDS)
 
 include(GenerateExportHeader)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 add_subdirectory(core)
 add_subdirectory(kcm)
 add_subdirectory(kcmplugin)
 if(NOT WIN32)
 	add_subdirectory(kio)
 	add_subdirectory(plasmoid)
 endif()
 add_subdirectory(icon)
 add_subdirectory(interfaces)
 
 option(EXPERIMENTALAPP_ENABLED OFF)
 if(EXPERIMENTALAPP_ENABLED)
     add_subdirectory(app)
 endif()
 add_subdirectory(daemon)
 add_subdirectory(plugins)
 add_subdirectory(cli)
 add_subdirectory(indicator)
 add_subdirectory(fileitemactionplugin)
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
 endif()
 
 install(FILES org.kde.kdeconnect.kcm.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index e73155a3..6dcfcc81 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -1,58 +1,67 @@
 project(KDEConnectCore)
 
 add_definitions(-DTRANSLATION_DOMAIN=\"kdeconnect-core\")
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
 )
 
 add_subdirectory(backends/lan)
 add_subdirectory(backends/loopback)
-add_subdirectory(backends/bluetooth)
+
+option(BLUETOOTH_ENABLED "Bluetooth support for kdeconnect" OFF)
+if(BLUETOOTH_ENABLED)
+    find_package(Qt5 REQUIRED COMPONENTS Bluetooth)
+    add_subdirectory(backends/bluetooth)
+endif()
 
 find_package(KF5Notifications 5.9 REQUIRED)
 
 set(kdeconnectcore_SRCS
     ${backends_kdeconnect_SRCS}
 
     backends/linkprovider.cpp
     backends/devicelink.cpp
     backends/pairinghandler.cpp
     backends/devicelinereader.cpp
 
     kdeconnectplugin.cpp
     kdeconnectpluginconfig.cpp
     pluginloader.cpp
 
     kdeconnectconfig.cpp
     dbushelper.cpp
     networkpackage.cpp
     filetransferjob.cpp
     daemon.cpp
     device.cpp
     core_debug.cpp
 )
 
 add_library(kdeconnectcore ${kdeconnectcore_SRCS})
 target_link_libraries(kdeconnectcore
 PUBLIC
     Qt5::Network
     KF5::CoreAddons
     qca-qt5
-    Qt5::Bluetooth
 PRIVATE
     Qt5::DBus
     Qt5::Gui
     KF5::I18n
     KF5::ConfigCore
 )
 
+if (BLUETOOTH_ENABLED)
+    target_compile_definitions(kdeconnectcore PRIVATE -DKDECONNECT_BLUETOOTH)
+    target_link_libraries(kdeconnectcore PRIVATE Qt5::Bluetooth)
+endif()
+
 set_target_properties(kdeconnectcore PROPERTIES
     VERSION ${KDECONNECT_VERSION}
     SOVERSION ${KDECONNECT_VERSION_MAJOR}
 )
 
 target_include_directories(kdeconnectcore PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 generate_export_header(kdeconnectcore EXPORT_FILE_NAME kdeconnectcore_export.h BASE_NAME KDEConnectCore)
 
 install(TARGETS kdeconnectcore EXPORT kdeconnectLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP)
diff --git a/core/daemon.cpp b/core/daemon.cpp
index c4536237..6fd4cb57 100644
--- a/core/daemon.cpp
+++ b/core/daemon.cpp
@@ -1,281 +1,287 @@
 /**
  * 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 "daemon.h"
 
 #include <QDBusConnection>
 #include <QNetworkAccessManager>
 #include <QDebug>
 #include <QPointer>
 
 #include "core_debug.h"
 #include "kdeconnectconfig.h"
 #include "networkpackage.h"
-#include "backends/bluetooth/bluetoothlinkprovider.h"
+
+#ifdef KDECONNECT_BLUETOOTH
+    #include "backends/bluetooth/bluetoothlinkprovider.h"
+#endif
+
 #include "backends/lan/lanlinkprovider.h"
 #include "backends/loopback/loopbacklinkprovider.h"
 #include "device.h"
 #include "backends/devicelink.h"
 #include "backends/linkprovider.h"
 
 static Daemon* s_instance = nullptr;
 
 struct DaemonPrivate
 {
     //Different ways to find devices and connect to them
     QSet<LinkProvider*> mLinkProviders;
 
     //Every known device
     QMap<QString, Device*> mDevices;
 
     QSet<QString> mDiscoveryModeAcquisitions;
 };
 
 Daemon* Daemon::instance()
 {
     Q_ASSERT(s_instance != nullptr);
     return s_instance;
 }
 
 Daemon::Daemon(QObject *parent, bool testMode)
     : QObject(parent)
     , d(new DaemonPrivate)
 {
     Q_ASSERT(!s_instance);
     s_instance = this;
     qCDebug(KDECONNECT_CORE) << "KdeConnect daemon starting";
 
     //Load backends
     if (testMode)
         d->mLinkProviders.insert(new LoopbackLinkProvider());
     else {
         d->mLinkProviders.insert(new LanLinkProvider());
-        d->mLinkProviders.insert(new BluetoothLinkProvider());
+        #ifdef KDECONNECT_BLUETOOTH
+            d->mLinkProviders.insert(new BluetoothLinkProvider());
+        #endif
     }
 
     //Read remebered paired devices
     const QStringList& list = KdeConnectConfig::instance()->trustedDevices();
     Q_FOREACH (const QString& id, list) {
         addDevice(new Device(this, id));
     }
 
     //Listen to new devices
     Q_FOREACH (LinkProvider* a, d->mLinkProviders) {
         connect(a, &LinkProvider::onConnectionReceived,
                 this, &Daemon::onNewDeviceLink);
         a->onStart();
     }
 
     //Register on DBus
     QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kdeconnect"));
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/modules/kdeconnect"), this, QDBusConnection::ExportScriptableContents);
 
     qCDebug(KDECONNECT_CORE) << "KdeConnect daemon started";
 }
 
 void Daemon::acquireDiscoveryMode(const QString &key)
 {
     bool oldState = d->mDiscoveryModeAcquisitions.isEmpty();
 
     d->mDiscoveryModeAcquisitions.insert(key);
 
     if (oldState != d->mDiscoveryModeAcquisitions.isEmpty()) {
         forceOnNetworkChange();
     }
 }
 
 void Daemon::releaseDiscoveryMode(const QString &key)
 {
     bool oldState = d->mDiscoveryModeAcquisitions.isEmpty();
 
     d->mDiscoveryModeAcquisitions.remove(key);
 
     if (oldState != d->mDiscoveryModeAcquisitions.isEmpty()) {
         cleanDevices();
     }
 }
 
 void Daemon::removeDevice(Device* device)
 {
     d->mDevices.remove(device->id());
     device->deleteLater();
     Q_EMIT deviceRemoved(device->id());
 }
 
 void Daemon::cleanDevices()
 {
     Q_FOREACH (Device* device, d->mDevices) {
         if (device->isTrusted()) {
             continue;
         }
         device->cleanUnneededLinks();
         //If there are no links remaining
         if (!device->isReachable()) {
             removeDevice(device);
         }
     }
 }
 
 void Daemon::forceOnNetworkChange()
 {
     qCDebug(KDECONNECT_CORE) << "Sending onNetworkChange to " << d->mLinkProviders.size() << " LinkProviders";
     Q_FOREACH (LinkProvider* a, d->mLinkProviders) {
         a->onNetworkChange();
     }
 }
 
 Device*Daemon::getDevice(const QString& deviceId)
 {
     Q_FOREACH (Device* device, d->mDevices) {
         if (device->id() == deviceId) {
             return device;
         }
     }
     return Q_NULLPTR;
 }
 
 QStringList Daemon::devices(bool onlyReachable, bool onlyTrusted) const
 {
     QStringList ret;
     Q_FOREACH (Device* device, d->mDevices) {
         if (onlyReachable && !device->isReachable()) continue;
         if (onlyTrusted && !device->isTrusted()) continue;
         ret.append(device->id());
     }
     return ret;
 }
 
 void Daemon::onNewDeviceLink(const NetworkPackage& identityPackage, DeviceLink* dl)
 {
     const QString& id = identityPackage.get<QString>(QStringLiteral("deviceId"));
 
     //qCDebug(KDECONNECT_CORE) << "Device discovered" << id << "via" << dl->provider()->name();
 
     if (d->mDevices.contains(id)) {
         qCDebug(KDECONNECT_CORE) << "It is a known device" << identityPackage.get<QString>(QStringLiteral("deviceName"));
         Device* device = d->mDevices[id];
         bool wasReachable = device->isReachable();
         device->addLink(identityPackage, dl);
         if (!wasReachable) {
             Q_EMIT deviceVisibilityChanged(id, true);
         }
     } else {
         qCDebug(KDECONNECT_CORE) << "It is a new device" << identityPackage.get<QString>(QStringLiteral("deviceName"));
         Device* device = new Device(this, identityPackage, dl);
 
         //we discard the connections that we created but it's not paired.
         if (!isDiscoveringDevices() && !device->isTrusted() && !dl->linkShouldBeKeptAlive()) {
             device->deleteLater();
         } else {
             addDevice(device);
         }
     }
 }
 
 void Daemon::onDeviceStatusChanged()
 {
     Device* device = (Device*)sender();
 
     //qCDebug(KDECONNECT_CORE) << "Device" << device->name() << "status changed. Reachable:" << device->isReachable() << ". Paired: " << device->isPaired();
 
     if (!device->isReachable() && !device->isTrusted()) {
         //qCDebug(KDECONNECT_CORE) << "Destroying device" << device->name();
         removeDevice(device);
     } else {
         Q_EMIT deviceVisibilityChanged(device->id(), device->isReachable());
     }
 
 }
 
 void Daemon::setAnnouncedName(const QString &name)
 {
     qCDebug(KDECONNECT_CORE()) << "Announcing name";
     KdeConnectConfig::instance()->setName(name);
     forceOnNetworkChange();
     Q_EMIT announcedNameChanged(name);
 }
 
 QString Daemon::announcedName()
 {
     return KdeConnectConfig::instance()->name();
 }
 
 QNetworkAccessManager* Daemon::networkAccessManager()
 {
     static QPointer<QNetworkAccessManager> manager;
     if (!manager) {
         manager = new QNetworkAccessManager(this);
     }
     return manager;
 }
 
 QList<Device*> Daemon::devicesList() const
 {
     return d->mDevices.values();
 }
 
 bool Daemon::isDiscoveringDevices() const
 {
     return !d->mDiscoveryModeAcquisitions.isEmpty();
 }
 
 QString Daemon::deviceIdByName(const QString &name) const
 {
     Q_FOREACH (Device* d, d->mDevices) {
         if (d->name() == name && d->isTrusted())
             return d->id();
     }
     return {};
 }
 
 void Daemon::addDevice(Device* device)
 {
     const QString id = device->id();
     connect(device, &Device::reachableChanged, this, &Daemon::onDeviceStatusChanged);
     connect(device, &Device::trustedChanged, this, &Daemon::onDeviceStatusChanged);
     connect(device, &Device::hasPairingRequestsChanged, this, &Daemon::pairingRequestsChanged);
     connect(device, &Device::hasPairingRequestsChanged, this, [this, device](bool hasPairingRequests) {
         if (hasPairingRequests)
             askPairingConfirmation(device);
     } );
     d->mDevices[id] = device;
 
     Q_EMIT deviceAdded(id);
 }
 
 QStringList Daemon::pairingRequests() const
 {
     QStringList ret;
     for(Device* dev: d->mDevices) {
         if (dev->hasPairingRequests())
             ret += dev->id();
     }
     return ret;
 }
 
 Daemon::~Daemon()
 {
 
 }
 
 QString Daemon::selfId() const
 {
     return KdeConnectConfig::instance()->deviceId();
 }