File indexing completed on 2024-04-28 03:52:01

 /*
  * BluezQt - Asynchronous Bluez wrapper library
  *
  * SPDX-FileCopyrightText: 2014 David Rosca <nowrep@gmail.com>
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  */
 
 #include "device.h"
 #include "device_p.h"
 #include "pendingcall.h"
 #include "utils.h"
 
 namespace BluezQt
 {
 Device::Device(const QString &path, const QVariantMap &properties, AdapterPtr adapter)
     : QObject()
     , d(new DevicePrivate(path, properties, adapter))
 {
 }
 
 Device::~Device() = default;
 
 DevicePtr Device::toSharedPtr() const
 {
     return d->q.toStrongRef();
 }
 
 QString Device::ubi() const
 {
     return d->m_bluezDevice->path();
 }
 
 QString Device::address() const
 {
     return d->m_address;
 }
 
 QString Device::name() const
 {
     return d->m_alias;
 }
 
 PendingCall *Device::setName(const QString &name)
 {
     return new PendingCall(d->setDBusProperty(QStringLiteral("Alias"), name), PendingCall::ReturnVoid, this);
 }
 
 QString Device::friendlyName() const
 {
     if (name().isEmpty() || name() == remoteName()) {
         return name();
     }
     if (remoteName().isEmpty()) {
         return name();
     }
     return QStringLiteral("%1 (%2)").arg(name(), remoteName());
 }
 
 QString Device::remoteName() const
 {
     return d->m_name;
 }
 
 quint32 Device::deviceClass() const
 {
     return d->m_deviceClass;
 }
 
 Device::Type Device::type() const
 {
     if (deviceClass() == 0) {
         return appearanceToType(appearance());
     }
 
     return classToType(d->m_deviceClass);
 }
 
 quint16 Device::appearance() const
 {
     return d->m_appearance;
 }
 
 QString Device::icon() const
 {
     switch (type()) {
     case Headset:
         return QStringLiteral("audio-headset");
     case Headphones:
         return QStringLiteral("audio-headphones");
     default:
         return d->m_icon.isEmpty() ? QStringLiteral("preferences-system-bluetooth") : d->m_icon;
     }
 }
 
 bool Device::isPaired() const
 {
     return d->m_paired;
 }
 
 bool Device::isTrusted() const
 {
     return d->m_trusted;
 }
 
 PendingCall *Device::setTrusted(bool trusted)
 {
     return new PendingCall(d->setDBusProperty(QStringLiteral("Trusted"), trusted), PendingCall::ReturnVoid, this);
 }
 
 bool Device::isBlocked() const
 {
     return d->m_blocked;
 }
 
 PendingCall *Device::setBlocked(bool blocked)
 {
     return new PendingCall(d->setDBusProperty(QStringLiteral("Blocked"), blocked), PendingCall::ReturnVoid, this);
 }
 
 bool Device::hasLegacyPairing() const
 {
     return d->m_legacyPairing;
 }
 
 qint16 Device::rssi() const
 {
     return d->m_rssi;
 }
 
 ManData Device::manufacturerData() const
 {
     return d->m_manufacturerData;
 }
 
 bool Device::isServicesResolved() const
 {
     return d->m_servicesResolved;
 }
 
 bool Device::isConnected() const
 {
     return d->m_connected;
 }
 
 QStringList Device::uuids() const
 {
     return d->m_uuids;
 }
 
 QString Device::modalias() const
 {
     return d->m_modalias;
 }
 
 QHash<QString, QByteArray> Device::serviceData() const
 {
     return d->m_serviceData;
 }
 
 BatteryPtr Device::battery() const
 {
     return d->m_battery;
 }
 
 InputPtr Device::input() const
 {
     return d->m_input;
 }
 
 MediaPlayerPtr Device::mediaPlayer() const
 {
     return d->m_mediaPlayer;
 }
 
 MediaTransportPtr Device::mediaTransport() const
 {
     return d->m_mediaTransport;
 }
 
 AdapterPtr Device::adapter() const
 {
     return d->m_adapter;
 }
 
 QList<GattServiceRemotePtr> Device::gattServices() const
 {
     return d->m_services;
 }
 
 QString Device::typeToString(Device::Type type)
 {
     switch (type) {
     case Device::Phone:
         return QStringLiteral("phone");
     case Device::Modem:
         return QStringLiteral("modem");
     case Device::Computer:
         return QStringLiteral("computer");
     case Device::Network:
         return QStringLiteral("network");
     case Device::Headset:
         return QStringLiteral("headset");
     case Device::Headphones:
         return QStringLiteral("headphones");
     case Device::AudioVideo:
         return QStringLiteral("audiovideo");
     case Device::Keyboard:
         return QStringLiteral("keyboard");
     case Device::Mouse:
         return QStringLiteral("mouse");
     case Device::Joypad:
         return QStringLiteral("joypad");
     case Device::Tablet:
         return QStringLiteral("tablet");
     case Device::Peripheral:
         return QStringLiteral("peripheral");
     case Device::Camera:
         return QStringLiteral("camera");
     case Device::Printer:
         return QStringLiteral("printer");
     case Device::Imaging:
         return QStringLiteral("imaging");
     case Device::Wearable:
         return QStringLiteral("wearable");
     case Device::Toy:
         return QStringLiteral("toy");
     case Device::Health:
         return QStringLiteral("health");
     default:
         return QStringLiteral("uncategorized");
     }
 }
 
 Device::Type Device::stringToType(const QString &typeString)
 {
     if (typeString == QLatin1String("phone")) {
         return Device::Phone;
     } else if (typeString == QLatin1String("modem")) {
         return Device::Modem;
     } else if (typeString == QLatin1String("computer")) {
         return Device::Computer;
     } else if (typeString == QLatin1String("network")) {
         return Device::Network;
     } else if (typeString == QLatin1String("headset")) {
         return Device::Headset;
     } else if (typeString == QLatin1String("headphones")) {
         return Device::Headphones;
     } else if (typeString == QLatin1String("audio")) {
         return Device::AudioVideo;
     } else if (typeString == QLatin1String("keyboard")) {
         return Device::Keyboard;
     } else if (typeString == QLatin1String("mouse")) {
         return Device::Mouse;
     } else if (typeString == QLatin1String("joypad")) {
         return Device::Joypad;
     } else if (typeString == QLatin1String("tablet")) {
         return Device::Tablet;
     } else if (typeString == QLatin1String("peripheral")) {
         return Device::Peripheral;
     } else if (typeString == QLatin1String("camera")) {
         return Device::Camera;
     } else if (typeString == QLatin1String("printer")) {
         return Device::Printer;
     } else if (typeString == QLatin1String("imaging")) {
         return Device::Imaging;
     } else if (typeString == QLatin1String("wearable")) {
         return Device::Wearable;
     } else if (typeString == QLatin1String("toy")) {
         return Device::Toy;
     } else if (typeString == QLatin1String("health")) {
         return Device::Health;
     }
     return Device::Uncategorized;
 }
 
 PendingCall *Device::connectToDevice()
 {
     return new PendingCall(d->m_bluezDevice->Connect(), PendingCall::ReturnVoid, this);
 }
 
 PendingCall *Device::disconnectFromDevice()
 {
     return new PendingCall(d->m_bluezDevice->Disconnect(), PendingCall::ReturnVoid, this);
 }
 
 PendingCall *Device::connectProfile(const QString &uuid)
 {
     return new PendingCall(d->m_bluezDevice->ConnectProfile(uuid), PendingCall::ReturnVoid, this);
 }
 
 PendingCall *Device::disconnectProfile(const QString &uuid)
 {
     return new PendingCall(d->m_bluezDevice->DisconnectProfile(uuid), PendingCall::ReturnVoid, this);
 }
 
 PendingCall *Device::pair()
 {
     return new PendingCall(d->m_bluezDevice->Pair(), PendingCall::ReturnVoid, this);
 }
 
 PendingCall *Device::cancelPairing()
 {
     return new PendingCall(d->m_bluezDevice->CancelPairing(), PendingCall::ReturnVoid, this);
 }
 
 } // namespace BluezQt
 
 #include "moc_device.cpp"