File indexing completed on 2024-04-28 05:26:13

 /*
  *  SPDX-FileCopyrightText: 2010-2012 Alejandro Fiestas Olivares <afiestas@kde.org>
  *  SPDX-FileCopyrightText: 2010 Eduardo Robles Elvira <edulix@gmail.com>
  *  SPDX-FileCopyrightText: 2010 Rafael Fernández López <ereslibre@kde.org>
  *  SPDX-FileCopyrightText: 2010 UFO Coders <info@ufocoders.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "kiobluetooth.h"
 #include "filereceiversettings.h"
 #include "version.h"
 
 #include <QCoreApplication>
 #include <QDBusMetaType>
 #include <QThread>
 
 #include <KLocalizedString>
 
 #include <BluezQt/Services>
 
 // Pseudo plugin class to embed meta data
 class KIOPluginForMetaData : public QObject
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.kde.kio.worker.bluetooth" FILE "bluetooth.json")
 };
 
 extern "C" int Q_DECL_EXPORT kdemain(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
 
     if (argc != 4) {
         fprintf(stderr, "Usage: kio_bluetooth protocol domain-socket1 domain-socket2\n");
         exit(-1);
     }
 
     KioBluetooth worker(argv[2], argv[3]);
     worker.dispatchLoop();
     return 0;
 }
 
 KioBluetooth::KioBluetooth(const QByteArray &pool, const QByteArray &app)
     : KIO::WorkerBase(QByteArrayLiteral("bluetooth"), pool, app)
 {
     qDBusRegisterMetaType<DeviceInfo>();
     qDBusRegisterMetaType<QMapDeviceInfo>();
 
     m_hasCurrentHost = false;
 
     Service sendFile;
     sendFile.name = i18n("Send File");
     sendFile.icon = QStringLiteral("edit-copy");
     sendFile.mimetype = QStringLiteral("application/vnd.kde.bluedevil-sendfile");
     sendFile.uuid = BluezQt::Services::ObexObjectPush;
 
     Service browseFiles;
     browseFiles.name = i18n("Browse Files");
     browseFiles.icon = QStringLiteral("edit-find");
     browseFiles.mimetype = QString();
     browseFiles.uuid = BluezQt::Services::ObexFileTransfer;
 
     m_supportedServices.insert(sendFile.uuid, sendFile);
     m_supportedServices.insert(browseFiles.uuid, browseFiles);
 
     qCDebug(BLUETOOTH) << "Kio Bluetooth instanced!";
 
     m_kded = new org::kde::BlueDevil(QStringLiteral("org.kde.kded6"), QStringLiteral("/modules/bluedevil"), QDBusConnection::sessionBus());
 
     if (!m_kded->isOnline()) {
         qCDebug(BLUETOOTH) << "Bluetooth is offline";
         infoMessage(i18n("No Bluetooth adapters have been found."));
         return;
     }
 }
 
 QList<KioBluetooth::Service> KioBluetooth::getSupportedServices(const QStringList &uuids)
 {
     qCDebug(BLUETOOTH) << "supported services: " << uuids;
 
     QList<Service> retValue;
     for (const QString &uuid : uuids) {
         if (m_supportedServices.contains(uuid)) {
             retValue << m_supportedServices[uuid];
         }
     }
     return retValue;
 }
 
 KIO::WorkerResult KioBluetooth::listRemoteDeviceServices()
 {
     infoMessage(i18n("Retrieving services…"));
 
     qCDebug(BLUETOOTH) << "Listing remote devices";
 
     const DeviceInfo &info = m_kded->device(m_currentHostAddress).value();
     if (info.isEmpty()) {
         qCDebug(BLUETOOTH) << "Invalid hostname!";
         infoMessage(i18n("This address is unavailable."));
         return KIO::WorkerResult::pass();
     }
 
     const QList<Service> &services = getSupportedServices(info.value(QStringLiteral("UUIDs")).split(QLatin1Char(',')));
 
     qCDebug(BLUETOOTH) << "Num of supported services: " << services.size();
 
     int i = 1;
     totalSize(services.count());
 
     for (const Service &service : services) {
         KIO::UDSEntry entry;
         entry.fastInsert(KIO::UDSEntry::UDS_NAME, service.uuid);
         entry.fastInsert(KIO::UDSEntry::UDS_DISPLAY_NAME, service.name);
         entry.fastInsert(KIO::UDSEntry::UDS_ICON_NAME, service.icon);
         entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH);
 
         // If it is browse files, act as a folder
         if (service.uuid == BluezQt::Services::ObexFileTransfer) {
             QUrl obexUrl;
             obexUrl.setScheme(QStringLiteral("obexftp"));
             obexUrl.setHost(m_currentHostname.replace(QLatin1Char(':'), QLatin1Char('-')).toUpper());
             entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
             entry.fastInsert(KIO::UDSEntry::UDS_URL, obexUrl.toString());
         } else {
             entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFREG);
         }
 
         if (service.mimetype.isEmpty()) {
             entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/vnd.kde.bluedevil.service"));
         } else {
             entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, service.mimetype);
         }
 
         listEntry(entry);
         processedSize(i++);
     }
 
     infoMessage(QString());
     return KIO::WorkerResult::pass();
 }
 
 void KioBluetooth::listDownload()
 {
     KIO::UDSEntry entry;
     entry.clear();
     entry.fastInsert(KIO::UDSEntry::UDS_URL, FileReceiverSettings::saveUrl().toDisplayString());
     entry.fastInsert(KIO::UDSEntry::UDS_NAME, i18n("Received Files"));
     entry.fastInsert(KIO::UDSEntry::UDS_ICON_NAME, QStringLiteral("folder-downloads"));
     entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH);
     entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
     listEntry(entry);
 }
 
 void KioBluetooth::listDevices()
 {
     qCDebug(BLUETOOTH) << "Asking kded for devices";
     const QMapDeviceInfo &devices = m_kded->allDevices().value();
     qCDebug(BLUETOOTH) << devices.keys();
 
     for (const DeviceInfo &device : devices) {
         listDevice(device);
     }
 
     m_kded->startDiscovering(10 * 1000);
 
     infoMessage(i18n("Scanning for new devices…"));
 }
 
 void KioBluetooth::listDevice(const DeviceInfo device)
 {
     qCDebug(BLUETOOTH) << device;
     if (getSupportedServices(device[QStringLiteral("UUIDs")].split(QStringLiteral(","))).isEmpty()) {
         return;
     }
     QString target = QStringLiteral("bluetooth://");
     target.append(QString(device[QStringLiteral("address")]).replace(QLatin1Char(':'), QLatin1Char('-')) + QLatin1Char('/'));
 
     KIO::UDSEntry entry;
     entry.fastInsert(KIO::UDSEntry::UDS_URL, target);
     entry.fastInsert(KIO::UDSEntry::UDS_NAME, device[QStringLiteral("name")]);
     entry.fastInsert(KIO::UDSEntry::UDS_ICON_NAME, device[QStringLiteral("icon")]);
     entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
     entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH);
     entry.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/vnd.kde.bluedevil.device"));
     listEntry(entry);
 }
 
 KIO::WorkerResult KioBluetooth::listDir(const QUrl &url)
 {
     qCDebug(BLUETOOTH) << "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 we are not online (ie. there's no working bluetooth adapter), list an empty dir
     qCDebug(BLUETOOTH) << m_kded->isOnline().value();
     if (!m_kded->isOnline().value()) {
         infoMessage(i18n("No Bluetooth adapters have been found."));
         return KIO::WorkerResult::pass();
     }
 
     if (!m_hasCurrentHost) {
         listDownload();
         listDevices();
         return KIO::WorkerResult::pass();
     } else {
         return listRemoteDeviceServices();
     }
 }
 
 KIO::WorkerResult KioBluetooth::stat(const QUrl &url)
 {
     qCDebug(BLUETOOTH) << "Stat: " << url;
     return KIO::WorkerResult::pass();
 }
 
 KIO::WorkerResult KioBluetooth::get(const QUrl &url)
 {
     m_kded->stopDiscovering();
     qCDebug(BLUETOOTH) << "Get: " << url;
     qCDebug(BLUETOOTH) << m_supportedServices.value(url.fileName()).mimetype;
     mimeType(m_supportedServices.value(url.fileName()).mimetype);
     return KIO::WorkerResult::pass();
 }
 
 void KioBluetooth::setHost(const QString &hostname, quint16 port, const QString &user, const QString &pass)
 {
     qCDebug(BLUETOOTH) << "Setting host: " << hostname;
 
     // In this kio only the hostname (constHostname) is used
     Q_UNUSED(port)
     Q_UNUSED(user)
     Q_UNUSED(pass)
 
     if (hostname.isEmpty()) {
         m_hasCurrentHost = false;
     } else {
         m_hasCurrentHost = true;
 
         m_currentHostname = hostname;
         m_currentHostAddress = hostname.toUpper();
         m_currentHostAddress.replace(QLatin1Char('-'), QLatin1Char(':'));
     }
 }
 
 Q_LOGGING_CATEGORY(BLUETOOTH, "bluedevil.kio_bluetooth")
 
 #include "kiobluetooth.moc"
 
 #include "moc_kiobluetooth.cpp"