diff options
Diffstat (limited to 'tests/bttestui/btlocaldevice.cpp')
| -rw-r--r-- | tests/bttestui/btlocaldevice.cpp | 710 |
1 files changed, 710 insertions, 0 deletions
diff --git a/tests/bttestui/btlocaldevice.cpp b/tests/bttestui/btlocaldevice.cpp new file mode 100644 index 00000000..b73a2a73 --- /dev/null +++ b/tests/bttestui/btlocaldevice.cpp @@ -0,0 +1,710 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** 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 Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "btlocaldevice.h" +#include <QDebug> +#include <QTimer> +#include <QtBluetooth/QBluetoothServiceInfo> + +#define BTCHAT_DEVICE_ADDR "00:15:83:38:17:C3" + +//same uuid as examples/bluetooth/btchat +#define TEST_SERVICE_UUID "e8e10f95-1a70-4b27-9ccf-02010264e9c8" + +BtLocalDevice::BtLocalDevice(QObject *parent) : + QObject(parent) +{ + localDevice = new QBluetoothLocalDevice(this); + connect(localDevice, SIGNAL(error(QBluetoothLocalDevice::Error)), + this, SIGNAL(error(QBluetoothLocalDevice::Error))); + connect(localDevice, SIGNAL(hostModeStateChanged(QBluetoothLocalDevice::HostMode)), + this, SIGNAL(hostModeStateChanged())); + connect(localDevice, SIGNAL(pairingFinished(QBluetoothAddress,QBluetoothLocalDevice::Pairing)), + this, SLOT(pairingFinished(QBluetoothAddress,QBluetoothLocalDevice::Pairing))); + connect(localDevice, SIGNAL(deviceConnected(QBluetoothAddress)), + this, SLOT(connected(QBluetoothAddress))); + connect(localDevice, SIGNAL(deviceDisconnected(QBluetoothAddress)), + this, SLOT(disconnected(QBluetoothAddress))); + connect(localDevice, SIGNAL(pairingDisplayConfirmation(QBluetoothAddress,QString)), + this, SLOT(pairingDisplayConfirmation(QBluetoothAddress,QString))); + + if (localDevice->isValid()) { + deviceAgent = new QBluetoothDeviceDiscoveryAgent(this); + connect(deviceAgent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)), + this, SLOT(deviceDiscovered(QBluetoothDeviceInfo))); + connect(deviceAgent, SIGNAL(finished()), + this, SLOT(discoveryFinished())); + connect(deviceAgent, SIGNAL(error(QBluetoothDeviceDiscoveryAgent::Error)), + this, SLOT(discoveryError(QBluetoothDeviceDiscoveryAgent::Error))); + connect(deviceAgent, SIGNAL(canceled()), + this, SLOT(discoveryCanceled())); + + serviceAgent = new QBluetoothServiceDiscoveryAgent(this); + connect(serviceAgent, SIGNAL(serviceDiscovered(QBluetoothServiceInfo)), + this, SLOT(serviceDiscovered(QBluetoothServiceInfo))); + connect(serviceAgent, SIGNAL(finished()), + this, SLOT(serviceDiscoveryFinished())); + connect(serviceAgent, SIGNAL(canceled()), + this, SLOT(serviceDiscoveryCanceled())); + connect(serviceAgent, SIGNAL(error(QBluetoothServiceDiscoveryAgent::Error)), + this, SLOT(serviceDiscoveryError(QBluetoothServiceDiscoveryAgent::Error))); + + socket = new QBluetoothSocket(this); + connect(socket, SIGNAL(stateChanged(QBluetoothSocket::SocketState)), + this, SLOT(socketStateChanged(QBluetoothSocket::SocketState))); + connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)), + this, SLOT(socketError(QBluetoothSocket::SocketError))); + connect(socket, SIGNAL(connected()), this, SLOT(socketConnected())); + connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); + connect(socket, SIGNAL(readyRead()), this, SLOT(readData())); + + server = new QBluetoothServer(QBluetoothServiceInfo::RfcommProtocol, this); + server->setSecurityFlags(QBluetooth::NoSecurity); + connect(server, SIGNAL(newConnection()), this, SLOT(serverNewConnection())); + connect(server, SIGNAL(error(QBluetoothServer::Error)), + this, SLOT(serverError(QBluetoothServer::Error))); + } else { + deviceAgent = 0; + serviceAgent = 0; + } +} + +BtLocalDevice::~BtLocalDevice() +{ + while (!serverSockets.isEmpty()) + { + QBluetoothSocket* s = serverSockets.takeFirst(); + s->abort(); + s->deleteLater(); + } +} + +QString BtLocalDevice::hostMode() const +{ + switch (localDevice->hostMode()) { + case QBluetoothLocalDevice::HostDiscoverable: + return QStringLiteral("HostMode: Discoverable"); + case QBluetoothLocalDevice::HostConnectable: + return QStringLiteral("HostMode: Connectable"); + case QBluetoothLocalDevice::HostDiscoverableLimitedInquiry: + return QStringLiteral("HostMode: DiscoverableLimit"); + case QBluetoothLocalDevice::HostPoweredOff: + return QStringLiteral("HostMode: Powered Off"); + } + + return QStringLiteral("HostMode: <None>"); +} + +void BtLocalDevice::setHostMode(int newMode) +{ + localDevice->setHostMode((QBluetoothLocalDevice::HostMode)newMode); +} + +void BtLocalDevice::requestPairingUpdate(bool isPairing) +{ + QBluetoothAddress baddr(BTCHAT_DEVICE_ADDR); + if (baddr.isNull()) + return; + + if (isPairing) + localDevice->requestPairing(baddr, QBluetoothLocalDevice::Paired); + else + localDevice->requestPairing(baddr, QBluetoothLocalDevice::Unpaired); + + for (int i = 0; i < foundTestServers.count(); i++) { + if (isPairing) + localDevice->requestPairing(foundTestServers.at(i).device().address(), + QBluetoothLocalDevice::Paired); + else + localDevice->requestPairing(foundTestServers.at(i).device().address(), + QBluetoothLocalDevice::Unpaired); + } +} + +void BtLocalDevice::pairingFinished(const QBluetoothAddress &address, QBluetoothLocalDevice::Pairing pairing) +{ + qDebug() << "(Un)Pairing finished" << address.toString() << pairing; +} + +void BtLocalDevice::connected(const QBluetoothAddress &addr) +{ + qDebug() << "Newly connected device" << addr.toString(); +} + +void BtLocalDevice::disconnected(const QBluetoothAddress &addr) +{ + qDebug() << "Newly disconnected device" << addr.toString(); +} + +void BtLocalDevice::pairingDisplayConfirmation(const QBluetoothAddress &address, const QString &pin) +{ + Q_UNUSED(pin); + Q_UNUSED(address); + QTimer::singleShot(3000, this, SLOT(confirmPairing())); +} + +void BtLocalDevice::confirmPairing() +{ + static bool confirm = false; + confirm = !confirm; //toggle + qDebug() << "######" << "Sending pairing confirmation: " << confirm; + localDevice->pairingConfirmation(confirm); +} + +void BtLocalDevice::deviceDiscovered(const QBluetoothDeviceInfo &info) +{ + QString services; + if (info.serviceClasses() & QBluetoothDeviceInfo::PositioningService) + services += "Position|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::NetworkingService) + services += "Network|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::RenderingService) + services += "Rendering|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::CapturingService) + services += "Capturing|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::ObjectTransferService) + services += "ObjectTra|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::AudioService) + services += "Audio|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::TelephonyService) + services += "Telephony|"; + if (info.serviceClasses() & QBluetoothDeviceInfo::InformationService) + services += "Information|"; + + services.truncate(services.length()-1); //cut last '/' + + qDebug() << "Found new device: " << info.name() << info.isValid() << info.address().toString() + << info.rssi() << info.majorDeviceClass() + << info.minorDeviceClass() << services; + +} + +void BtLocalDevice::discoveryFinished() +{ + qDebug() << "###### Device Discovery Finished"; +} + +void BtLocalDevice::discoveryCanceled() +{ + qDebug() << "###### Device Discovery Canceled"; +} + +void BtLocalDevice::discoveryError(QBluetoothDeviceDiscoveryAgent::Error error) +{ + QBluetoothDeviceDiscoveryAgent *client = qobject_cast<QBluetoothDeviceDiscoveryAgent *>(sender()); + if (!client) + return; + qDebug() << "###### Device Discovery Error:" << error << (client ? client->errorString() : QString()); +} + +void BtLocalDevice::startDiscovery() +{ + if (deviceAgent) { + qDebug() << "###### Starting device discovery process"; + deviceAgent->start(); + } +} + +void BtLocalDevice::stopDiscovery() +{ + if (deviceAgent) { + qDebug() << "Stopping device discovery process"; + deviceAgent->stop(); + } +} + +void BtLocalDevice::startServiceDiscovery(bool isMinimalDiscovery) +{ + if (serviceAgent) { + qDebug() << "###### Starting service discovery process"; + serviceAgent->start(isMinimalDiscovery + ? QBluetoothServiceDiscoveryAgent::MinimalDiscovery + : QBluetoothServiceDiscoveryAgent::FullDiscovery); + } +} + +void BtLocalDevice::stopServiceDiscovery() +{ + if (serviceAgent) { + qDebug() << "Stopping service discovery process"; + serviceAgent->stop(); + } +} + +void BtLocalDevice::serviceDiscovered(const QBluetoothServiceInfo &info) +{ + + qDebug() << "$$ Found new service" << info.device().address().toString() + << info.serviceUuid() << info.serviceName() << info.serviceDescription(); + + if (info.serviceUuid() == QBluetoothUuid(QString(TEST_SERVICE_UUID)) + || info.serviceClassUuids().contains(QBluetoothUuid(QString(TEST_SERVICE_UUID)))) + { + //This is here to detect the test server for SPP testing later on + bool alreadyKnown = false; + foreach (const QBluetoothServiceInfo& found, foundTestServers) { + if (found.device().address() == info.device().address()) { + alreadyKnown = true; + break; + } + } + + if (!alreadyKnown) { + foundTestServers.append(info); + qDebug() << "@@@@@@@@ Adding:" << info.device().address().toString(); + } + } +} + +void BtLocalDevice::serviceDiscoveryFinished() +{ + qDebug() << "###### Service Discovery Finished"; +} + +void BtLocalDevice::serviceDiscoveryCanceled() +{ + qDebug() << "###### Service Discovery Canceled"; +} + +void BtLocalDevice::serviceDiscoveryError(QBluetoothServiceDiscoveryAgent::Error error) +{ + QBluetoothServiceDiscoveryAgent *client = qobject_cast<QBluetoothServiceDiscoveryAgent *>(sender()); + if (!client) + return; + qDebug() << "###### Service Discovery Error:" << error << (client ? client->errorString() : QString()); +} + +void BtLocalDevice::dumpServiceDiscovery() +{ + if (serviceAgent) { + qDebug() << "Service Discovery active:" << serviceAgent->isActive(); + qDebug() << "Error:" << serviceAgent->error() << serviceAgent->errorString(); + QList<QBluetoothServiceInfo> list = serviceAgent->discoveredServices(); + qDebug() << "Discovered Services:" << list.count(); + + foreach (const QBluetoothServiceInfo &i, list) { + qDebug() << i.device().address().toString() << i.device().name() << i.serviceName(); + } + + qDebug() << "###### TestServer offered by:"; + foreach (const QBluetoothServiceInfo& found, foundTestServers) { + qDebug() << found.device().name() << found.device().address().toString(); + } + } +} + +void BtLocalDevice::connectToService() +{ + if (socket) + socket->connectToService(QBluetoothAddress(BTCHAT_DEVICE_ADDR),QBluetoothUuid(QString(TEST_SERVICE_UUID))); +} + +void BtLocalDevice::connectToServiceViaSearch() +{ + if (socket) { + qDebug() << "###### Connecting to service socket"; + if (!foundTestServers.isEmpty()) { + QBluetoothServiceInfo info = foundTestServers.at(0); + socket->connectToService(info.device().address(), QBluetoothUuid(QString(TEST_SERVICE_UUID))); + } else { + qWarning() << "Perform search for test service before triggering this function"; + } + } +} + +void BtLocalDevice::disconnectToService() +{ + if (socket) { + qDebug() << "###### Disconnecting socket"; + socket->disconnectFromService(); + } +} + +void BtLocalDevice::closeSocket() +{ + if (socket) { + qDebug() << "###### Closing socket"; + socket->close(); + } + + if (!serverSockets.isEmpty()) { + qDebug() << "###### Closing server sockets"; + foreach (QBluetoothSocket *s, serverSockets) + s->close(); + } +} + +void BtLocalDevice::abortSocket() +{ + if (socket) { + qDebug() << "###### Disconnecting socket"; + socket->abort(); + } +} + +void BtLocalDevice::socketConnected() +{ + qDebug() << "###### Socket connected"; +} + +void BtLocalDevice::socketDisconnected() +{ + qDebug() << "###### Socket disconnected"; +} + +void BtLocalDevice::socketError(QBluetoothSocket::SocketError error) +{ + QBluetoothSocket *client = qobject_cast<QBluetoothSocket *>(sender()); + + qDebug() << "###### Socket error" << error << (client ? client->errorString() : QString()); +} + +void BtLocalDevice::socketStateChanged(QBluetoothSocket::SocketState state) +{ + qDebug() << "###### Socket state" << state; + emit socketStateUpdate((int) state); +} + +void BtLocalDevice::dumpSocketInformation() +{ + if (socket) { + qDebug() << "*******************************"; + qDebug() << "Local info (addr, name, port):" << socket->localAddress().toString() + << socket->localName() << socket->localPort(); + qDebug() << "Peer Info (adr, name, port):" << socket->peerAddress().toString() + << socket->peerName() << socket->peerPort(); + qDebug() << "socket type:" << socket->socketType(); + qDebug() << "socket state:" << socket->state(); + QString tmp; + switch (socket->error()) { + case QBluetoothSocket::NoSocketError: tmp += "NoSocketError"; break; + case QBluetoothSocket::UnknownSocketError: tmp += "UnknownSocketError"; break; + case QBluetoothSocket::HostNotFoundError: tmp += "HostNotFoundError"; break; + case QBluetoothSocket::ServiceNotFoundError: tmp += "ServiceNotFound"; break; + case QBluetoothSocket::NetworkError: tmp += "NetworkError"; break; + //case QBluetoothSocket::OperationError: tmp+= "OperationError"; break; + case QBluetoothSocket::UnsupportedProtocolError: tmp += "UnsupportedProtocolError"; break; + default: tmp+= "Undefined"; break; + } + + qDebug() << "socket error:" << tmp << socket->errorString(); + } else { + qDebug() << "No valid socket existing"; + } +} + +void BtLocalDevice::writeData() +{ + const char * testData = "ABCABC\n"; + if (socket && socket->state() == QBluetoothSocket::ConnectedState) { + socket->write(testData); + } + foreach (QBluetoothSocket* client, serverSockets) { + client->write(testData); + } +} + +void BtLocalDevice::readData() +{ + if (socket) { + while (socket->canReadLine()) { + QByteArray line = socket->readLine().trimmed(); + qDebug() << ">>>>" << QString::fromUtf8(line.constData(), line.length()); + } + } +} + +void BtLocalDevice::serverError(QBluetoothServer::Error error) +{ + qDebug() << "###### Server socket error" << error; +} + +void BtLocalDevice::serverListenPort() +{ + if (server && localDevice) { + if (server->isListening() || serviceInfo.isRegistered()) { + qDebug() << "###### Already listening" << serviceInfo.isRegistered(); + return; + } + qDebug() << "###### Start listening via port"; + bool ret = server->listen(localDevice->address()); + qDebug() << "###### Listening(Expecting TRUE):" << ret; + + if (!ret) + return; + + QBluetoothServiceInfo::Sequence classId; + classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort)); + serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList, + classId); + + classId.prepend(QVariant::fromValue(QBluetoothUuid(QString(TEST_SERVICE_UUID)))); + serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId); + + // Service name, description and provider + serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("Bt Chat Server")); + serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription, + tr("Example bluetooth chat server")); + serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("qt-project.org")); + + // Service UUID set + serviceInfo.setServiceUuid(QBluetoothUuid(QString(TEST_SERVICE_UUID))); + + + // Service Discoverability + serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, + QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup)); + + // Protocol descriptor list + QBluetoothServiceInfo::Sequence protocolDescriptorList; + QBluetoothServiceInfo::Sequence protocol; + protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::L2cap)); + protocolDescriptorList.append(QVariant::fromValue(protocol)); + protocol.clear(); + protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm)) + << QVariant::fromValue(quint8(server->serverPort())); + protocolDescriptorList.append(QVariant::fromValue(protocol)); + serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList, + protocolDescriptorList); + + //Register service + qDebug() << "###### Registering service on" << localDevice->address().toString(); + bool result = serviceInfo.registerService(localDevice->address()); + if (!result) { + server->close(); + qDebug() << "###### Reverting registration due to SDP failure."; + } + } + +} + +void BtLocalDevice::serverListenUuid() +{ + if (server) { + if (server->isListening() || serviceInfo.isRegistered()) { + qDebug() << "###### Already listening" << serviceInfo.isRegistered(); + return; + } + qDebug() << "###### Start listening via UUID"; + serviceInfo = server->listen(QBluetoothUuid(QString(TEST_SERVICE_UUID)), tr("Bt Chat Server")); + qDebug() << "###### Listening(Expecting TRUE, TRUE):" << serviceInfo.isRegistered() << serviceInfo.isValid(); + } +} + +void BtLocalDevice::serverClose() +{ + if (server) { + qDebug() << "###### Closing Server socket"; + if (serviceInfo.isRegistered()) + serviceInfo.unregisterService(); + server->close(); + } +} + +void BtLocalDevice::serverNewConnection() +{ + qDebug() << "###### New incoming server connection, pending:" << server->hasPendingConnections(); + if (!server->hasPendingConnections()) { + qDebug() << "FAIL: expected pending server connection"; + return; + } + QBluetoothSocket *client = server->nextPendingConnection(); + if (!client) { + qDebug() << "FAIL: Cannot obtain pending server connection"; + return; + } + + client->setParent(this); + connect(client, SIGNAL(disconnected()), this, SLOT(clientSocketDisconnected())); + connect(client, SIGNAL(readyRead()), this, SLOT(clientSocketReadyRead())); + connect(client, SIGNAL(stateChanged(QBluetoothSocket::SocketState)), + this, SLOT(socketStateChanged(QBluetoothSocket::SocketState))); + connect(client, SIGNAL(error(QBluetoothSocket::SocketError)), + this, SLOT(socketError(QBluetoothSocket::SocketError))); + connect(client, SIGNAL(connected()), this, SLOT(socketConnected())); + serverSockets.append(client); +} + +void BtLocalDevice::clientSocketDisconnected() +{ + QBluetoothSocket *client = qobject_cast<QBluetoothSocket *>(sender()); + if (!client) + return; + + qDebug() << "######" << "Removing server socket connection"; + + serverSockets.removeOne(client); + client->deleteLater(); +} + + +void BtLocalDevice::clientSocketReadyRead() +{ + QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender()); + if (!socket) + return; + + while (socket->canReadLine()) { + QByteArray line = socket->readLine().trimmed(); + qDebug() << ">>(" << socket->peerName() << ")>>" + << QString::fromUtf8(line.constData(), line.length()); + } +} + + +void BtLocalDevice::dumpServerInformation() +{ + static QBluetooth::SecurityFlags secFlag = QBluetooth::Authentication; + if (server) { + qDebug() << "*******************************"; + qDebug() << "server port:" <<server->serverPort() + << "type:" << server->serverType() + << "address:" << server->serverAddress().toString(); + qDebug() << "error:" << server->error(); + qDebug() << "listening:" << server->isListening() + << "hasPending:" << server->hasPendingConnections() + << "maxPending:" << server->maxPendingConnections(); + qDebug() << "security:" << server->securityFlags() << "Togling security flag"; + if (secFlag == QBluetooth::Authentication) + secFlag = QBluetooth::Encryption; + else + secFlag = QBluetooth::Authentication; + + //server->setSecurityFlags(secFlag); + + foreach (const QBluetoothSocket *client, serverSockets) { + qDebug() << "##" << client->localAddress().toString() + << client->localName() << client->localPort(); + qDebug() << "##" << client->peerAddress().toString() + << client->peerName() << client->peerPort(); + qDebug() << client->socketType() << client->state(); + QString tmp; + switch (client->error()) { + case QBluetoothSocket::NoSocketError: tmp += "NoSocketError"; break; + case QBluetoothSocket::UnknownSocketError: tmp += "UnknownSocketError"; break; + case QBluetoothSocket::HostNotFoundError: tmp += "HostNotFoundError"; break; + case QBluetoothSocket::ServiceNotFoundError: tmp += "ServiceNotFound"; break; + case QBluetoothSocket::NetworkError: tmp += "NetworkError"; break; + case QBluetoothSocket::UnsupportedProtocolError: tmp += "UnsupportedProtocolError"; break; + //case QBluetoothSocket::OperationError: tmp+= "OperationError"; break; + default: tmp += QString::number((int)client->error()); break; + } + + qDebug() << "socket error:" << tmp << client->errorString(); + } + } +} + +void BtLocalDevice::dumpInformation() +{ + qDebug() << "###### default local device"; + dumpLocalDevice(localDevice); + QList<QBluetoothHostInfo> list = QBluetoothLocalDevice::allDevices(); + qDebug() << "Found local devices: " << list.count(); + foreach (const QBluetoothHostInfo &info, list) { + qDebug() << " " << info.address().toString() << " " <<info.name(); + } + + QBluetoothAddress address(QStringLiteral("11:22:33:44:55:66")); + QBluetoothLocalDevice temp(address); + qDebug() << "###### 11:22:33:44:55:66 address valid:" << !address.isNull(); + dumpLocalDevice(&temp); + + QBluetoothAddress address2; + QBluetoothLocalDevice temp2(address2); + qDebug() << "###### 00:00:00:00:00:00 address valid:" << !address2.isNull(); + dumpLocalDevice(&temp2); + + const QBluetoothAddress BB(BTCHAT_DEVICE_ADDR); + qDebug() << "###### Bonding state with" << QString(BTCHAT_DEVICE_ADDR) << ":" << localDevice->pairingStatus(BB); + qDebug() << "###### Bonding state with" << address2.toString() << ": " << localDevice->pairingStatus(address2); + qDebug() << "###### Bonding state with" << address.toString() << ": " << localDevice->pairingStatus(address); + + qDebug() << "###### Connected Devices"; + foreach (const QBluetoothAddress &addr, localDevice->connectedDevices()) + qDebug() << " " << addr.toString(); + + qDebug() << "###### Discovered Devices"; + if (deviceAgent) + foreach (const QBluetoothDeviceInfo &info, deviceAgent->discoveredDevices()) + deviceDiscovered(info); + + QBluetoothDeviceDiscoveryAgent invalidAgent(QBluetoothAddress("11:22:33:44:55:66")); + invalidAgent.start(); + qDebug() << "######" << "Testing device discovery agent constructor with invalid address"; + qDebug() << "######" << (invalidAgent.error() == QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError) + << "(Expected: true)"; + QBluetoothDeviceDiscoveryAgent validAgent(localDevice->address()); + validAgent.start(); + qDebug() << "######" << (validAgent.error() == QBluetoothDeviceDiscoveryAgent::NoError) << "(Expected: true)"; + + QBluetoothServiceDiscoveryAgent invalidSAgent(QBluetoothAddress("11:22:33:44:55:66")); + invalidSAgent.start(); + qDebug() << "######" << "Testing service discovery agent constructor with invalid address"; + qDebug() << "######" << (invalidSAgent.error() == QBluetoothServiceDiscoveryAgent::InvalidBluetoothAdapterError) + << "(Expected: true)"; + QBluetoothServiceDiscoveryAgent validSAgent(localDevice->address()); + validSAgent.start(); + qDebug() << "######" << (validSAgent.error() == QBluetoothServiceDiscoveryAgent::NoError) << "(Expected: true)"; +} + +void BtLocalDevice::powerOn() +{ + qDebug() << "Powering on"; + localDevice->powerOn(); +} + +void BtLocalDevice::reset() +{ + emit error((QBluetoothLocalDevice::Error)1000); + if (serviceAgent) { + serviceAgent->clear(); + } + foundTestServers.clear(); +} + +void BtLocalDevice::dumpLocalDevice(QBluetoothLocalDevice *dev) +{ + qDebug() << " Valid: " << dev->isValid(); + qDebug() << " Name" << dev->name(); + qDebug() << " Address" << dev->address().toString(); + qDebug() << " HostMode" << dev->hostMode(); +} |