| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtBluetooth module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qbluetoothserviceinfo.h" |
| #include "qbluetoothserviceinfo_p.h" |
| |
| #include "bluez/manager_p.h" |
| #include "bluez/service_p.h" |
| #include "bluez/bluez5_helper_p.h" |
| #include "bluez/profilemanager1_p.h" |
| |
| #include <QtCore/QLoggingCategory> |
| #include <QtCore/QXmlStreamWriter> |
| #include <QtCore/QAtomicInt> |
| |
| QT_BEGIN_NAMESPACE |
| |
| Q_DECLARE_LOGGING_CATEGORY(QT_BT_BLUEZ) |
| |
| static const QLatin1String profilePathTemplate("/qt/profile"); |
| static QAtomicInt pathCounter; |
| |
| static void writeAttribute(QXmlStreamWriter *stream, const QVariant &attribute) |
| { |
| const QString unsignedFormat(QStringLiteral("0x%1")); |
| |
| switch (int(attribute.type())) { |
| case QMetaType::Void: |
| stream->writeEmptyElement(QStringLiteral("nil")); |
| break; |
| case QMetaType::UChar: |
| stream->writeEmptyElement(QStringLiteral("uint8")); |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(attribute.value<quint8>(), 2, 16, |
| QLatin1Char('0'))); |
| break; |
| case QMetaType::UShort: |
| stream->writeEmptyElement(QStringLiteral("uint16")); |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(attribute.value<quint16>(), 4, 16, |
| QLatin1Char('0'))); |
| break; |
| case QMetaType::UInt: |
| stream->writeEmptyElement(QStringLiteral("uint32")); |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(attribute.value<quint32>(), 8, 16, |
| QLatin1Char('0'))); |
| break; |
| case QMetaType::Char: |
| stream->writeEmptyElement(QStringLiteral("int8")); |
| stream->writeAttribute(QStringLiteral("value"), |
| QString::number(attribute.value<qint8>())); |
| break; |
| case QMetaType::Short: |
| stream->writeEmptyElement(QStringLiteral("int16")); |
| stream->writeAttribute(QStringLiteral("value"), |
| QString::number(attribute.value<qint16>())); |
| break; |
| case QMetaType::Int: |
| stream->writeEmptyElement(QStringLiteral("int32")); |
| stream->writeAttribute(QStringLiteral("value"), |
| QString::number(attribute.value<qint32>())); |
| break; |
| case QMetaType::QByteArray: |
| stream->writeEmptyElement(QStringLiteral("text")); |
| stream->writeAttribute(QStringLiteral("value"), |
| QString::fromLatin1(attribute.value<QByteArray>().toHex().constData())); |
| stream->writeAttribute(QStringLiteral("encoding"), QStringLiteral("hex")); |
| break; |
| case QMetaType::QString: |
| stream->writeEmptyElement(QStringLiteral("text")); |
| stream->writeAttribute(QStringLiteral("value"), attribute.value<QString>()); |
| stream->writeAttribute(QStringLiteral("encoding"), QStringLiteral("normal")); |
| break; |
| case QMetaType::Bool: |
| stream->writeEmptyElement(QStringLiteral("boolean")); |
| if (attribute.value<bool>()) |
| stream->writeAttribute(QStringLiteral("value"), QStringLiteral("true")); |
| else |
| stream->writeAttribute(QStringLiteral("value"), QStringLiteral("false")); |
| break; |
| case QMetaType::QUrl: |
| stream->writeEmptyElement(QStringLiteral("url")); |
| stream->writeAttribute(QStringLiteral("value"), attribute.value<QUrl>().toString()); |
| break; |
| case QVariant::UserType: |
| if (attribute.userType() == qMetaTypeId<QBluetoothUuid>()) { |
| stream->writeEmptyElement(QStringLiteral("uuid")); |
| |
| QBluetoothUuid uuid = attribute.value<QBluetoothUuid>(); |
| switch (uuid.minimumSize()) { |
| case 0: |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(quint16(0), 4, 16, QLatin1Char('0'))); |
| break; |
| case 2: |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(uuid.toUInt16(), 4, 16, |
| QLatin1Char('0'))); |
| break; |
| case 4: |
| stream->writeAttribute(QStringLiteral("value"), |
| unsignedFormat.arg(uuid.toUInt32(), 8, 16, |
| QLatin1Char('0'))); |
| break; |
| case 16: |
| stream->writeAttribute(QStringLiteral("value"), uuid.toString().mid(1, 36)); |
| break; |
| default: |
| stream->writeAttribute(QStringLiteral("value"), uuid.toString().mid(1, 36)); |
| } |
| } else if (attribute.userType() == qMetaTypeId<QBluetoothServiceInfo::Sequence>()) { |
| stream->writeStartElement(QStringLiteral("sequence")); |
| const QBluetoothServiceInfo::Sequence *sequence = |
| static_cast<const QBluetoothServiceInfo::Sequence *>(attribute.data()); |
| for (const QVariant &v : *sequence) |
| writeAttribute(stream, v); |
| stream->writeEndElement(); |
| } else if (attribute.userType() == qMetaTypeId<QBluetoothServiceInfo::Alternative>()) { |
| const QBluetoothServiceInfo::Alternative *alternative = |
| static_cast<const QBluetoothServiceInfo::Alternative *>(attribute.data()); |
| for (const QVariant &v : *alternative) |
| writeAttribute(stream, v); |
| stream->writeEndElement(); |
| } |
| break; |
| default: |
| qCWarning(QT_BT_BLUEZ) << "Unknown variant type", attribute.userType(); |
| } |
| } |
| |
| QBluetoothServiceInfoPrivate::QBluetoothServiceInfoPrivate() |
| : serviceRecord(0), registered(false) |
| { |
| if (isBluez5()) { |
| serviceBluez5 = new OrgBluezProfileManager1Interface( |
| QStringLiteral("org.bluez"), |
| QStringLiteral("/org/bluez"), |
| QDBusConnection::systemBus(), this); |
| } |
| } |
| |
| QBluetoothServiceInfoPrivate::~QBluetoothServiceInfoPrivate() |
| { |
| } |
| |
| bool QBluetoothServiceInfoPrivate::isRegistered() const |
| { |
| return registered; |
| } |
| |
| bool QBluetoothServiceInfoPrivate::unregisterService() |
| { |
| if (!registered) |
| return false; |
| |
| if (serviceBluez5) { // Bluez 5 |
| if (profilePath.isEmpty()) |
| return false; |
| |
| QDBusPendingReply<> reply = serviceBluez5->UnregisterProfile( |
| QDBusObjectPath(profilePath)); |
| reply.waitForFinished(); |
| if (reply.isError()) { |
| qCWarning(QT_BT_BLUEZ) << "Cannot unregister profile:" |
| << profilePath << reply.error().message(); |
| return false; |
| } |
| profilePath.clear(); |
| } else { // Bluez 4 |
| if (!ensureSdpConnection(currentLocalAdapter)) |
| return false; |
| |
| QDBusPendingReply<> reply = service->RemoveRecord(serviceRecord); |
| reply.waitForFinished(); |
| if (reply.isError()) |
| return false; |
| |
| serviceRecord = 0; |
| } |
| |
| registered = false; |
| return true; |
| } |
| |
| bool QBluetoothServiceInfoPrivate::ensureSdpConnection(const QBluetoothAddress &localAdapter) |
| { |
| if (service && currentLocalAdapter == localAdapter) |
| return true; |
| |
| delete service; |
| |
| OrgBluezManagerInterface manager(QStringLiteral("org.bluez"), QStringLiteral("/"), |
| QDBusConnection::systemBus()); |
| |
| |
| QDBusPendingReply<QDBusObjectPath> reply; |
| if (localAdapter.isNull()) |
| reply = manager.DefaultAdapter(); |
| else |
| reply = manager.FindAdapter(localAdapter.toString()); |
| reply.waitForFinished(); |
| if (reply.isError()) |
| return false; |
| |
| currentLocalAdapter = localAdapter; |
| service = new OrgBluezServiceInterface(QStringLiteral("org.bluez"), reply.value().path(), |
| QDBusConnection::systemBus(), this); |
| |
| return true; |
| } |
| |
| bool QBluetoothServiceInfoPrivate::registerService(const QBluetoothAddress &localAdapter) |
| { |
| if (serviceBluez5) { // Bluez 5 |
| if (registered) |
| return false; |
| } else { // Bluez 4 |
| //if new adapter unregister previous one first |
| if (registered && localAdapter != currentLocalAdapter) |
| unregisterService(); |
| |
| if (!ensureSdpConnection(localAdapter)) { |
| qCWarning(QT_BT_BLUEZ) << "SDP not connected. Cannot register"; |
| return false; |
| } |
| } |
| |
| QString xmlServiceRecord; |
| |
| QXmlStreamWriter stream(&xmlServiceRecord); |
| stream.setAutoFormatting(true); |
| |
| stream.writeStartDocument(QStringLiteral("1.0")); |
| |
| stream.writeStartElement(QStringLiteral("record")); |
| |
| const QString unsignedFormat(QStringLiteral("0x%1")); |
| |
| QMap<quint16, QVariant>::ConstIterator i = attributes.constBegin(); |
| while (i != attributes.constEnd()) { |
| stream.writeStartElement(QStringLiteral("attribute")); |
| stream.writeAttribute(QStringLiteral("id"), unsignedFormat.arg(i.key(), 4, 16, QLatin1Char('0'))); |
| writeAttribute(&stream, i.value()); |
| stream.writeEndElement(); |
| |
| ++i; |
| } |
| |
| stream.writeEndElement(); |
| |
| stream.writeEndDocument(); |
| |
| if (serviceBluez5) { // Bluez 5 |
| // create path |
| profilePath = profilePathTemplate; |
| profilePath.append(QString::fromLatin1("/%1%2/%3"). |
| arg(sanitizeNameForDBus(QCoreApplication::applicationName())). |
| arg(QCoreApplication::applicationPid()). |
| arg(pathCounter.fetchAndAddOrdered(1))); |
| |
| QVariantMap mapping; |
| mapping.insert(QStringLiteral("ServiceRecord"), xmlServiceRecord); |
| |
| // Strategy to pick service uuid |
| // 1.) use serviceUuid() |
| // 2.) use first custom uuid if available |
| // 3.) use first service class uuid |
| QBluetoothUuid profileUuid = attributes.value(QBluetoothServiceInfo::ServiceId) |
| .value<QBluetoothUuid>(); |
| QBluetoothUuid firstCustomUuid; |
| if (profileUuid.isNull()) { |
| const QVariant var = attributes.value(QBluetoothServiceInfo::ServiceClassIds); |
| if (var.isValid()) { |
| const QBluetoothServiceInfo::Sequence seq |
| = var.value<QBluetoothServiceInfo::Sequence>(); |
| QBluetoothUuid tempUuid; |
| |
| for (int i = 0; i < seq.count(); i++) { |
| tempUuid = seq.at(i).value<QBluetoothUuid>(); |
| if (tempUuid.isNull()) |
| continue; |
| |
| int size = tempUuid.minimumSize(); |
| if (size == 2 || size == 4) { // Base UUID derived |
| if (profileUuid.isNull()) |
| profileUuid = tempUuid; |
| } else if (firstCustomUuid.isNull()){ |
| firstCustomUuid = tempUuid; |
| } |
| } |
| } |
| } |
| |
| if (!firstCustomUuid.isNull()) |
| profileUuid = firstCustomUuid; |
| |
| QString uuidString = profileUuid.toString(); |
| uuidString.chop(1); // remove trailing '}' |
| uuidString.remove(0, 1); // remove beginning '{' |
| |
| qCDebug(QT_BT_BLUEZ) << "Registering profile under" << profilePath |
| << uuidString; |
| |
| QDBusPendingReply<> reply = serviceBluez5->RegisterProfile( |
| QDBusObjectPath(profilePath), |
| uuidString, |
| mapping); |
| reply.waitForFinished(); |
| if (reply.isError()) { |
| qCWarning(QT_BT_BLUEZ) << "Cannot register profile" << reply.error().message(); |
| return false; |
| } |
| } else { // Bluez 4 |
| if (!registered) { |
| QDBusPendingReply<uint> reply = service->AddRecord(xmlServiceRecord); |
| reply.waitForFinished(); |
| if (reply.isError()) { |
| qCWarning(QT_BT_BLUEZ) << "AddRecord returned error" << reply.error(); |
| return false; |
| } |
| |
| serviceRecord = reply.value(); |
| } else { |
| QDBusPendingReply<> reply = service->UpdateRecord(serviceRecord, xmlServiceRecord); |
| reply.waitForFinished(); |
| if (reply.isError()) { |
| qCWarning(QT_BT_BLUEZ) << "UpdateRecord returned error" << reply.error(); |
| return false; |
| } |
| } |
| } |
| |
| registered = true; |
| return true; |
| } |
| |
| QT_END_NAMESPACE |
