qiurui
/
qtconnectivity
mirror of https://github.com/qt/qtconnectivity.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Normalize QObject::connect() statements 

Some cases use the Q_PRIVATE_SLOT logic which does not require QObject
inheritance. Those cases were converted to lambda logic to avoid need for
QObject inheritance.

The Q_PRIVATE_SLOT macro was removed from qbluetoothdevicediscoveryagent.h.
This is not a BC problem because the macro expands to nothing. Only
moc recognizes the pattern.

Change-Id: Ic7cb4cde397f9b230b6fd0b4046e59e504583e58
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
This commit is contained in:
Alex Blasche 2018-08-22 15:21:15 +02:00
parent 77c3c1427d
commit 819bb06c2c
9 changed files with 111 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/bluetooth/qbluetoothdevicediscoveryagent.h
View File

@ -120,16 +120,6 @@ Q_SIGNALS:
private:
Q_DECLARE_PRIVATE(QBluetoothDeviceDiscoveryAgent)
QBluetoothDeviceDiscoveryAgentPrivate *d_ptr;
#if QT_CONFIG(bluez)
Q_PRIVATE_SLOT(d_func(), void _q_deviceFound(const QString &address, const QVariantMap &dict))
Q_PRIVATE_SLOT(d_func(), void _q_propertyChanged(const QString &name, const QDBusVariant &value))
Q_PRIVATE_SLOT(d_func(), void _q_InterfacesAdded(const QDBusObjectPath &path, InterfaceList interfaceList))
Q_PRIVATE_SLOT(d_func(), void _q_discoveryFinished())
Q_PRIVATE_SLOT(d_func(), void _q_discoveryInterrupted(const QString &path))
Q_PRIVATE_SLOT(d_func(), void _q_PropertiesChanged(const QString &interface, const QVariantMap &changed_properties, const QStringList &invalidated_properties))
Q_PRIVATE_SLOT(d_func(), void _q_extendedDeviceDiscoveryTimeout())
#endif
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QBluetoothDeviceDiscoveryAgent::DiscoveryMethods)

44
src/bluetooth/qbluetoothdevicediscoveryagent_bluez.cpp
View File

@ -67,7 +67,6 @@ QBluetoothDeviceDiscoveryAgentPrivate::QBluetoothDeviceDiscoveryAgentPrivate(
lowEnergySearchTimeout(-1), // remains -1 on BlueZ 4 -> timeout not supported
q_ptr(parent)
{
Q_Q(QBluetoothDeviceDiscoveryAgent);
if (isBluez5()) {
lowEnergySearchTimeout = 20000;
managerBluez5 = new OrgFreedesktopDBusObjectManagerInterface(
@ -75,8 +74,10 @@ QBluetoothDeviceDiscoveryAgentPrivate::QBluetoothDeviceDiscoveryAgentPrivate(
QStringLiteral("/"),
QDBusConnection::systemBus(), parent);
QObject::connect(managerBluez5,
SIGNAL(InterfacesAdded(QDBusObjectPath,InterfaceList)),
q, SLOT(_q_InterfacesAdded(QDBusObjectPath,InterfaceList)));
&OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded,
[this](const QDBusObjectPath &objectPath, InterfaceList interfacesAndProperties) {
this->_q_InterfacesAdded(objectPath, interfacesAndProperties);
});
// start private address monitoring
BluetoothManagement::instance();
@ -84,8 +85,9 @@ QBluetoothDeviceDiscoveryAgentPrivate::QBluetoothDeviceDiscoveryAgentPrivate(
manager = new OrgBluezManagerInterface(QStringLiteral("org.bluez"), QStringLiteral("/"),
QDBusConnection::systemBus(), parent);
QObject::connect(&extendedDiscoveryTimer,
SIGNAL(timeout()),
q, SLOT(_q_extendedDeviceDiscoveryTimeout()));
&QTimer::timeout, [this]() {
this->_q_extendedDeviceDiscoveryTimeout();
});
extendedDiscoveryTimer.setInterval(10000);
extendedDiscoveryTimer.setSingleShot(true);
}
@ -159,10 +161,14 @@ void QBluetoothDeviceDiscoveryAgentPrivate::start(QBluetoothDeviceDiscoveryAgent
QDBusConnection::systemBus());
Q_Q(QBluetoothDeviceDiscoveryAgent);
QObject::connect(adapter, SIGNAL(DeviceFound(QString, QVariantMap)),
q, SLOT(_q_deviceFound(QString, QVariantMap)));
QObject::connect(adapter, SIGNAL(PropertyChanged(QString, QDBusVariant)),
q, SLOT(_q_propertyChanged(QString, QDBusVariant)));
QObject::connect(adapter, &OrgBluezAdapterInterface::DeviceFound,
[this](const QString &address, const QVariantMap &dict) {
this->_q_deviceFound(address, dict);
});
QObject::connect(adapter, &OrgBluezAdapterInterface::PropertyChanged,
[this](const QString &name, const QDBusVariant &value) {
this->_q_propertyChanged(name, value);
});
QDBusPendingReply<QVariantMap> propertiesReply = adapter->GetProperties();
propertiesReply.waitForFinished();
@ -280,8 +286,10 @@ void QBluetoothDeviceDiscoveryAgentPrivate::startBluez5(QBluetoothDeviceDiscover
}
QtBluezDiscoveryManager::instance()->registerDiscoveryInterest(adapterBluez5->path());
QObject::connect(QtBluezDiscoveryManager::instance(), SIGNAL(discoveryInterrupted(QString)),
q, SLOT(_q_discoveryInterrupted(QString)));
QObject::connect(QtBluezDiscoveryManager::instance(), &QtBluezDiscoveryManager::discoveryInterrupted,
[this](const QString &path){
this->_q_discoveryInterrupted(path);
});
// collect initial set of information
QDBusPendingReply<ManagedObjectList> reply = managerBluez5->GetManagedObjects();
@ -312,8 +320,10 @@ void QBluetoothDeviceDiscoveryAgentPrivate::startBluez5(QBluetoothDeviceDiscover
if (!discoveryTimer) {
discoveryTimer = new QTimer(q);
discoveryTimer->setSingleShot(true);
QObject::connect(discoveryTimer, SIGNAL(timeout()),
q, SLOT(_q_discoveryFinished()));
QObject::connect(discoveryTimer, &QTimer::timeout,
[this]() {
this->_q_discoveryFinished();
});
}
if (lowEnergySearchTimeout > 0) { // otherwise no timeout and stop() required
@ -420,8 +430,12 @@ void QBluetoothDeviceDiscoveryAgentPrivate::deviceFoundBluez5(const QString& dev
OrgFreedesktopDBusPropertiesInterface *prop = new OrgFreedesktopDBusPropertiesInterface(
QStringLiteral("org.bluez"), devicePath, QDBusConnection::systemBus(), q);
QObject::connect(prop, SIGNAL(PropertiesChanged(QString,QVariantMap,QStringList)),
q, SLOT(_q_PropertiesChanged(QString,QVariantMap,QStringList)));
QObject::connect(prop, &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged,
[this](const QString &interface, const QVariantMap &changedProperties,
const QStringList &invalidatedProperties) {
this->_q_PropertiesChanged(interface, changedProperties, invalidatedProperties);
});
// remember what we have to cleanup
propertyMonitors.append(prop);

60
src/bluetooth/qbluetoothlocaldevice_bluez.cpp
View File

@ -397,8 +397,8 @@ void QBluetoothLocalDevice::requestPairing(const QBluetoothAddress &address, Pai
QStringLiteral("NoInputNoOutput"));
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), d_ptr,
SLOT(pairingCompleted(QDBusPendingCallWatcher *)));
connect(watcher, &QDBusPendingCallWatcher::finished,
d_ptr, &QBluetoothLocalDevicePrivate::pairingCompleted);
if (reply.isError())
qCWarning(QT_BT_BLUEZ) << Q_FUNC_INFO << reply.error() << d_ptr->agent_path;
@ -492,8 +492,8 @@ void QBluetoothLocalDevicePrivate::requestPairingBluez5(const QBluetoothAddress
pairingDiscoveryTimer = new QTimer(this);
pairingDiscoveryTimer->setSingleShot(true);
pairingDiscoveryTimer->setInterval(20000); //20s
connect(pairingDiscoveryTimer, SIGNAL(timeout()),
SLOT(pairingDiscoveryTimedOut()));
connect(pairingDiscoveryTimer, &QTimer::timeout,
this, &QBluetoothLocalDevicePrivate::pairingDiscoveryTimedOut);
}
qCDebug(QT_BT_BLUEZ) << "Initiating discovery for pairing on" << targetAddress.toString();
@ -555,8 +555,8 @@ void QBluetoothLocalDevicePrivate::processPairingBluez5(const QString &objectPat
//initiate the pairing
QDBusPendingReply<> pairReply = pairingTarget->Pair();
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pairReply, this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
SLOT(pairingCompleted(QDBusPendingCallWatcher*)));
connect(watcher, &QDBusPendingCallWatcher::finished,
this, &QBluetoothLocalDevicePrivate::pairingCompleted);
return;
}
@ -678,12 +678,12 @@ void QBluetoothLocalDevicePrivate::connectDeviceChanges()
{
if (adapter) { // invalid QBluetoothLocalDevice due to wrong local adapter address
createCache();
connect(adapter, SIGNAL(PropertyChanged(QString, QDBusVariant)),
SLOT(PropertyChanged(QString, QDBusVariant)));
connect(adapter, SIGNAL(DeviceCreated(QDBusObjectPath)),
SLOT(_q_deviceCreated(QDBusObjectPath)));
connect(adapter, SIGNAL(DeviceRemoved(QDBusObjectPath)),
SLOT(_q_deviceRemoved(QDBusObjectPath)));
connect(adapter, &OrgBluezAdapterInterface::PropertyChanged,
this, &QBluetoothLocalDevicePrivate::PropertyChanged);
connect(adapter, &OrgBluezAdapterInterface::DeviceCreated,
this, &QBluetoothLocalDevicePrivate::_q_deviceCreated);
connect(adapter, &OrgBluezAdapterInterface::DeviceRemoved,
this, &QBluetoothLocalDevicePrivate::_q_deviceRemoved);
} else if (adapterBluez5 && managerBluez5) {
//setup property change notifications for all existing devices
QDBusPendingReply<ManagedObjectList> reply = managerBluez5->GetManagedObjects();
@ -710,8 +710,8 @@ void QBluetoothLocalDevicePrivate::connectDeviceChanges()
monitor = new OrgFreedesktopDBusPropertiesInterface(QStringLiteral("org.bluez"),
path.path(),
QDBusConnection::systemBus(), this);
connect(monitor, SIGNAL(PropertiesChanged(QString,QVariantMap,QStringList)),
SLOT(PropertiesChanged(QString,QVariantMap,QStringList)));
connect(monitor, &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged,
this, &QBluetoothLocalDevicePrivate::PropertiesChanged);
deviceChangeMonitors.insert(path.path(), monitor);
if (ifaceValues.value(QStringLiteral("Connected"), false).toBool()) {
@ -788,13 +788,13 @@ void QBluetoothLocalDevicePrivate::initializeAdapter()
// monitor case when local adapter is removed
manager = man.take();
connect(manager, SIGNAL(AdapterRemoved(QDBusObjectPath)),
this, SLOT(adapterRemoved(QDBusObjectPath)));
connect(manager, &OrgBluezManagerInterface::AdapterRemoved,
this, &QBluetoothLocalDevicePrivate::adapterRemoved);
currentMode = static_cast<QBluetoothLocalDevice::HostMode>(-1);
if (adapter) {
connect(adapter, SIGNAL(PropertyChanged(QString, QDBusVariant)),
SLOT(PropertyChanged(QString, QDBusVariant)));
connect(adapter, &OrgBluezAdapterInterface::PropertyChanged,
this, &QBluetoothLocalDevicePrivate::PropertyChanged);
agent_path = agentPath;
agent_path.append(QString::fromLatin1("/%1").arg(QRandomGenerator::global()->generate()));
@ -813,10 +813,10 @@ void QBluetoothLocalDevicePrivate::initializeAdapterBluez5()
QStringLiteral("/"),
QDBusConnection::systemBus(), this);
connect(managerBluez5, SIGNAL(InterfacesAdded(QDBusObjectPath,InterfaceList)),
SLOT(InterfacesAdded(QDBusObjectPath,InterfaceList)));
connect(managerBluez5, SIGNAL(InterfacesRemoved(QDBusObjectPath,QStringList)),
SLOT(InterfacesRemoved(QDBusObjectPath,QStringList)));
connect(managerBluez5, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded,
this, &QBluetoothLocalDevicePrivate::InterfacesAdded);
connect(managerBluez5, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved,
this, &QBluetoothLocalDevicePrivate::InterfacesRemoved);
bool ok = true;
const QString adapterPath = findAdapterForAddress(localAddress, &ok);
@ -833,8 +833,8 @@ void QBluetoothLocalDevicePrivate::initializeAdapterBluez5()
adapterProperties = new OrgFreedesktopDBusPropertiesInterface(
QStringLiteral("org.bluez"), adapterBluez5->path(),
QDBusConnection::systemBus(), this);
connect(adapterProperties, SIGNAL(PropertiesChanged(QString,QVariantMap,QStringList)),
SLOT(PropertiesChanged(QString,QVariantMap,QStringList)));
connect(adapterProperties, &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged,
this, &QBluetoothLocalDevicePrivate::PropertiesChanged);
}
currentMode = static_cast<QBluetoothLocalDevice::HostMode>(-1);
@ -914,8 +914,8 @@ void QBluetoothLocalDevicePrivate::InterfacesAdded(const QDBusObjectPath &object
QStringLiteral("org.bluez"),
object_path.path(),
QDBusConnection::systemBus());
connect(monitor, SIGNAL(PropertiesChanged(QString,QVariantMap,QStringList)),
SLOT(PropertiesChanged(QString,QVariantMap,QStringList)));
connect(monitor, &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged,
this, &QBluetoothLocalDevicePrivate::PropertiesChanged);
deviceChangeMonitors.insert(object_path.path(), monitor);
const QVariantMap ifaceValues = interfaces_and_properties.value(QStringLiteral("org.bluez.Device1"));
@ -1034,8 +1034,8 @@ void QBluetoothLocalDevicePrivate::_q_deviceCreated(const QDBusObjectPath &devic
= new OrgBluezDeviceInterface(QStringLiteral("org.bluez"),
device.path(),
QDBusConnection::systemBus(), this);
connect(deviceInterface, SIGNAL(PropertyChanged(QString, QDBusVariant)),
SLOT(_q_devicePropertyChanged(QString, QDBusVariant)));
connect(deviceInterface, &OrgBluezDeviceInterface::PropertyChanged,
this, &QBluetoothLocalDevicePrivate::_q_devicePropertyChanged);
devices << deviceInterface;
QDBusPendingReply<QVariantMap> properties
= deviceInterface->asyncCall(QStringLiteral("GetProperties"));
@ -1112,8 +1112,8 @@ void QBluetoothLocalDevicePrivate::createCache()
new OrgBluezDeviceInterface(QStringLiteral("org.bluez"),
device.path(),
QDBusConnection::systemBus(), this);
connect(deviceInterface, SIGNAL(PropertyChanged(QString,QDBusVariant)),
SLOT(_q_devicePropertyChanged(QString,QDBusVariant)));
connect(deviceInterface, &OrgBluezDeviceInterface::PropertyChanged,
this, &QBluetoothLocalDevicePrivate::_q_devicePropertyChanged);
devices << deviceInterface;
QDBusPendingReply<QVariantMap> properties

4
src/bluetooth/qbluetoothserver.h
View File

@ -104,10 +104,6 @@ protected:
private:
Q_DECLARE_PRIVATE(QBluetoothServer)
#if QT_CONFIG(bluez)
Q_PRIVATE_SLOT(d_func(), void _q_newConnection())
#endif
};
QT_END_NAMESPACE

5
src/bluetooth/qbluetoothserver_bluez.cpp
View File

@ -252,7 +252,10 @@ bool QBluetoothServer::listen(const QBluetoothAddress &address, quint16 port)
if (!d->socketNotifier) {
d->socketNotifier = new QSocketNotifier(d->socket->socketDescriptor(),
QSocketNotifier::Read);
connect(d->socketNotifier, SIGNAL(activated(int)), this, SLOT(_q_newConnection()));
connect(d->socketNotifier, &QSocketNotifier::activated,
[d](){
d->_q_newConnection();
});
}
return true;

20
src/bluetooth/qbluetoothservicediscoveryagent.cpp
View File

@ -434,13 +434,19 @@ void QBluetoothServiceDiscoveryAgentPrivate::startDeviceDiscovery()
#else
deviceDiscoveryAgent = new QBluetoothDeviceDiscoveryAgent(q);
#endif
QObject::connect(deviceDiscoveryAgent, SIGNAL(finished()),
q, SLOT(_q_deviceDiscoveryFinished()));
QObject::connect(deviceDiscoveryAgent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)),
q, SLOT(_q_deviceDiscovered(QBluetoothDeviceInfo)));
QObject::connect(deviceDiscoveryAgent, SIGNAL(error(QBluetoothDeviceDiscoveryAgent::Error)),
q, SLOT(_q_deviceDiscoveryError(QBluetoothDeviceDiscoveryAgent::Error)));
QObject::connect(deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished,
[this](){
this->_q_deviceDiscoveryFinished();
});
QObject::connect(deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered,
[this](const QBluetoothDeviceInfo &info){
this->_q_deviceDiscovered(info);
});
QObject::connect(deviceDiscoveryAgent,
QOverload<QBluetoothDeviceDiscoveryAgent::Error>::of(&QBluetoothDeviceDiscoveryAgent::error),
[this](QBluetoothDeviceDiscoveryAgent::Error newError){
this->_q_deviceDiscoveryError(newError);
});
}
setDiscoveryState(DeviceDiscovery);

19
src/bluetooth/qbluetoothservicediscoveryagent.h
View File

@ -110,25 +110,6 @@ Q_SIGNALS:
private:
QBluetoothServiceDiscoveryAgentPrivate *d_ptr;
Q_PRIVATE_SLOT(d_func(), void _q_deviceDiscovered(const QBluetoothDeviceInfo &info))
Q_PRIVATE_SLOT(d_func(), void _q_deviceDiscoveryFinished())
Q_PRIVATE_SLOT(d_func(), void _q_deviceDiscoveryError(QBluetoothDeviceDiscoveryAgent::Error))
Q_PRIVATE_SLOT(d_func(), void _q_serviceDiscoveryFinished())
#if QT_CONFIG(bluez)
Q_PRIVATE_SLOT(d_func(), void _q_discoveredServices(QDBusPendingCallWatcher*))
Q_PRIVATE_SLOT(d_func(), void _q_createdDevice(QDBusPendingCallWatcher*))
Q_PRIVATE_SLOT(d_func(), void _q_foundDevice(QDBusPendingCallWatcher*))
Q_PRIVATE_SLOT(d_func(), void _q_sdpScannerDone(int,QProcess::ExitStatus))
#endif
#ifdef QT_ANDROID_BLUETOOTH
Q_PRIVATE_SLOT(d_func(), void _q_processFetchedUuids(const QBluetoothAddress &address,
const QList<QBluetoothUuid>&))
Q_PRIVATE_SLOT(d_func(), void _q_fetchUuidsTimeout())
Q_PRIVATE_SLOT(d_func(), void _q_hostModeStateChanged(QBluetoothLocalDevice::HostMode state))
#endif
};
QT_END_NAMESPACE

23
src/bluetooth/qbluetoothservicediscoveryagent_android.cpp
View File

@ -37,6 +37,7 @@
**
****************************************************************************/
#include <QtCore/qcoreapplication.h>
#include <QtCore/QLoggingCategory>
#include <QtCore/QTimer>
#include <QtCore/private/qjnihelpers_p.h>
@ -198,14 +199,18 @@ void QBluetoothServiceDiscoveryAgentPrivate::start(const QBluetoothAddress &addr
//Full discovery uses BluetoothDevice.fetchUuidsWithSdp()
if (!receiver) {
receiver = new ServiceDiscoveryBroadcastReceiver();
QObject::connect(receiver, SIGNAL(uuidFetchFinished(QBluetoothAddress,QList<QBluetoothUuid>)),
q, SLOT(_q_processFetchedUuids(QBluetoothAddress,QList<QBluetoothUuid>)));
QObject::connect(receiver, &ServiceDiscoveryBroadcastReceiver::uuidFetchFinished,
[this](const QBluetoothAddress &address, const QList<QBluetoothUuid>& uuids) {
this->_q_processFetchedUuids(address, uuids);
});
}
if (!localDeviceReceiver) {
localDeviceReceiver = new LocalDeviceBroadcastReceiver();
QObject::connect(localDeviceReceiver, SIGNAL(hostModeStateChanged(QBluetoothLocalDevice::HostMode)),
q, SLOT(_q_hostModeStateChanged(QBluetoothLocalDevice::HostMode)));
QObject::connect(localDeviceReceiver, &LocalDeviceBroadcastReceiver::hostModeStateChanged,
[this](QBluetoothLocalDevice::HostMode state){
this->_q_hostModeStateChanged(state);
});
}
jboolean result = remoteDevice.callMethod<jboolean>("fetchUuidsWithSdp");
@ -245,8 +250,9 @@ void QBluetoothServiceDiscoveryAgentPrivate::_q_processFetchedUuids(
//could not find any service for the current address/device -> go to next one
if (address.isNull() || uuids.isEmpty()) {
if (discoveredDevices.count() == 1) {
Q_Q(QBluetoothServiceDiscoveryAgent);
QTimer::singleShot(4000, q, SLOT(_q_fetchUuidsTimeout()));
QTimer::singleShot(4000, qApp, [this]() {
this->_q_fetchUuidsTimeout();
});
}
_q_serviceDiscoveryFinished();
return;
@ -295,8 +301,9 @@ void QBluetoothServiceDiscoveryAgentPrivate::_q_processFetchedUuids(
//the discovery on the last device cannot immediately finish
//we have to grant the 2 seconds timeout delay
if (discoveredDevices.count() == 1) {
Q_Q(QBluetoothServiceDiscoveryAgent);
QTimer::singleShot(4000, q, SLOT(_q_fetchUuidsTimeout()));
QTimer::singleShot(4000, qApp, [this]() {
this->_q_fetchUuidsTimeout();
});
return;
}

30
src/bluetooth/qbluetoothservicediscoveryagent_bluez.cpp
View File

@ -128,8 +128,10 @@ void QBluetoothServiceDiscoveryAgentPrivate::start(const QBluetoothAddress &addr
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(deviceObjectPath, q);
watcher->setProperty("_q_BTaddress", QVariant::fromValue(address));
QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
q, SLOT(_q_foundDevice(QDBusPendingCallWatcher*)));
QObject::connect(watcher, &QDBusPendingCallWatcher::finished,
[this](QDBusPendingCallWatcher *watcher){
this->_q_foundDevice(watcher);
});
}
// Bluez 5
@ -212,8 +214,11 @@ void QBluetoothServiceDiscoveryAgentPrivate::runExternalSdpScan(
if (QT_BT_BLUEZ().isDebugEnabled())
sdpScannerProcess->setProcessChannelMode(QProcess::ForwardedErrorChannel);
sdpScannerProcess->setProgram(fileInfo.canonicalFilePath());
q->connect(sdpScannerProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
q, SLOT(_q_sdpScannerDone(int,QProcess::ExitStatus)));
q->connect(sdpScannerProcess,
QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
[this](int exitCode, QProcess::ExitStatus status){
this->_q_sdpScannerDone(exitCode, status);
});
}
QStringList arguments;
@ -326,7 +331,7 @@ void QBluetoothServiceDiscoveryAgentPrivate::stop()
{
qCDebug(QT_BT_BLUEZ) << Q_FUNC_INFO << "Stop called";
if (device) {
//we are waiting for _q_discoveredServices() slot to be called
//we are waiting for _q_discoveredServices() to be called
// adapter is already 0
QDBusPendingReply<> reply = device->CancelDiscovery();
reply.waitForFinished();
@ -335,7 +340,7 @@ void QBluetoothServiceDiscoveryAgentPrivate::stop()
device = nullptr;
Q_ASSERT(!adapter);
} else if (adapter) {
//we are waiting for _q_createdDevice() slot to be called
//we are waiting for _q_createdDevice() to be called
adapter->deleteLater();
adapter = nullptr;
Q_ASSERT(!device);
@ -390,8 +395,11 @@ void QBluetoothServiceDiscoveryAgentPrivate::_q_foundDevice(QDBusPendingCallWatc
deviceObjectPath = adapter->CreateDevice(address.toString());
watcher = new QDBusPendingCallWatcher(deviceObjectPath, q);
watcher->setProperty("_q_BTaddress", QVariant::fromValue(address));
QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
q, SLOT(_q_createdDevice(QDBusPendingCallWatcher*)));
QObject::connect(watcher, &QDBusPendingCallWatcher::finished,
[this](QDBusPendingCallWatcher *watcher){
this->_q_createdDevice(watcher);
});
return;
}
@ -528,8 +536,10 @@ void QBluetoothServiceDiscoveryAgentPrivate::discoverServices(const QString &dev
QDBusPendingReply<ServiceMap> discoverReply = device->DiscoverServices(pattern);
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(discoverReply, q);
QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
q, SLOT(_q_discoveredServices(QDBusPendingCallWatcher*)));
QObject::connect(watcher, &QDBusPendingCallWatcher::finished,
[this](QDBusPendingCallWatcher *watcher){
this->_q_discoveredServices(watcher);
});
}
}