void BtLocalDevice::serviceDiscovered(const QBluetoothServiceInfo &info) { QStringList classIds; foreach (const QBluetoothUuid &uuid, info.serviceClassUuids()) classIds.append(uuid.toString()); qDebug() << "$$ Found new service" << info.device().address().toString() << info.serviceUuid() << info.serviceName() << info.serviceDescription() << classIds; 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 QBluetoothSocket::doDeviceDiscovery(const QBluetoothServiceInfo &service, OpenMode openMode) { Q_D(QBluetoothSocket); setSocketState(QBluetoothSocket::ServiceLookupState); qCDebug(QT_BT) << "Starting discovery"; if(d->discoveryAgent) { d->discoveryAgent->stop(); delete d->discoveryAgent; } d->discoveryAgent = new QBluetoothServiceDiscoveryAgent(this); d->discoveryAgent->setRemoteAddress(service.device().address()); //qDebug() << "Got agent"; connect(d->discoveryAgent, SIGNAL(serviceDiscovered(QBluetoothServiceInfo)), this, SLOT(serviceDiscovered(QBluetoothServiceInfo))); connect(d->discoveryAgent, SIGNAL(finished()), this, SLOT(discoveryFinished())); d->openMode = openMode; if(!service.serviceUuid().isNull()) d->discoveryAgent->setUuidFilter(service.serviceUuid()); if(!service.serviceClassUuids().isEmpty()) d->discoveryAgent->setUuidFilter(service.serviceClassUuids()); // we have to ID the service somehow Q_ASSERT(!d->discoveryAgent->uuidFilter().isEmpty()); qCDebug(QT_BT) << "UUID filter" << d->discoveryAgent->uuidFilter(); d->discoveryAgent->start(QBluetoothServiceDiscoveryAgent::FullDiscovery); }
/*! Attempts to connect to the service described by \a service. The socket is opened in the given \a openMode. The \l socketType() may change depending on the protocol required by \a service. The socket first enters ConnectingState and attempts to connect to the device providing \a service. If a connection is established, QBluetoothSocket enters ConnectedState and emits connected(). At any point, the socket can emit error() to signal that an error occurred. Note that most platforms require a pairing prior to connecting to the remote device. Otherwise the connection process may fail. \sa state(), disconnectFromService() */ void QBluetoothSocket::connectToService(const QBluetoothServiceInfo &service, OpenMode openMode) { Q_D(QBluetoothSocket); if (state() != QBluetoothSocket::UnconnectedState && state() != QBluetoothSocket::ServiceLookupState) { qCWarning(QT_BT) << "QBluetoothSocket::connectToService called on busy socket"; d->errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress"); setSocketError(QBluetoothSocket::OperationError); return; } #if defined(QT_QNX_BLUETOOTH) || defined(QT_ANDROID_BLUETOOTH) if (!d->ensureNativeSocket(service.socketProtocol())) { d->errorString = tr("Socket type not supported"); setSocketError(QBluetoothSocket::UnsupportedProtocolError); return; } d->connectToService(service.device().address(), service.serviceUuid(), openMode); #else if (service.protocolServiceMultiplexer() > 0) { if (!d->ensureNativeSocket(QBluetoothServiceInfo::L2capProtocol)) { d->errorString = tr("Unknown socket error"); setSocketError(UnknownSocketError); return; } d->connectToService(service.device().address(), service.protocolServiceMultiplexer(), openMode); } else if (service.serverChannel() > 0) { if (!d->ensureNativeSocket(QBluetoothServiceInfo::RfcommProtocol)) { d->errorString = tr("Unknown socket error"); setSocketError(UnknownSocketError); return; } d->connectToService(service.device().address(), service.serverChannel(), openMode); } else { // try doing service discovery to see if we can find the socket if(service.serviceUuid().isNull()){ qCWarning(QT_BT) << "No port, no PSM, and no UUID provided, unable to connect"; return; } qCDebug(QT_BT) << "Need a port/psm, doing discovery"; doDeviceDiscovery(service, openMode); } #endif }
bool QBluetoothServiceDiscoveryAgentPrivate::isDuplicatedService( const QBluetoothServiceInfo &serviceInfo) const { //check the service is not already part of our known list for (int j = 0; j < discoveredServices.count(); j++) { const QBluetoothServiceInfo &info = discoveredServices.at(j); if (info.device() == serviceInfo.device() && info.serviceClassUuids() == serviceInfo.serviceClassUuids() && info.serviceUuid() == serviceInfo.serviceUuid()) { return true; } } return false; }
void QBluetoothServiceDiscoveryAgentPrivate::populateDiscoveredServices(const QBluetoothDeviceInfo &remoteDevice, const QList<QBluetoothUuid> &uuids) { /* Android doesn't provide decent SDP data. A list of uuids is close to meaning-less * * The following approach is chosen: * - If we see an SPP service class and we see * one or more custom uuids we match them up. Such services will always be SPP services. * - If we see a custom uuid but no SPP uuid then we return * BluetoothServiceInfo instance with just a servuceUuid (no service class set) * - Any other service uuid will stand on its own. * */ Q_Q(QBluetoothServiceDiscoveryAgent); //find SPP and custom uuid QBluetoothUuid uuid; int sppIndex = -1; QVector<int> customUuids; for (int i = 0; i < uuids.count(); i++) { uuid = uuids.at(i); if (uuid.isNull()) continue; //check for SPP protocol bool ok = false; quint16 uuid16 = uuid.toUInt16(&ok); if (ok && uuid16 == QBluetoothUuid::SerialPort) sppIndex = i; //check for custom uuid if (uuid.minimumSize() == 16) customUuids.append(i); } for (int i = 0; i < uuids.count(); i++) { if (i == sppIndex && !customUuids.isEmpty()) continue; QBluetoothServiceInfo serviceInfo; serviceInfo.setDevice(remoteDevice); QBluetoothServiceInfo::Sequence protocolDescriptorList; { QBluetoothServiceInfo::Sequence protocol; protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::L2cap)); protocolDescriptorList.append(QVariant::fromValue(protocol)); } if (customUuids.contains(i) && sppIndex > -1) { //we have a custom uuid of service class type SPP //set rfcomm protocol QBluetoothServiceInfo::Sequence protocol; protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm)) << QVariant::fromValue(0); protocolDescriptorList.append(QVariant::fromValue(protocol)); //set SPP service class uuid QBluetoothServiceInfo::Sequence classId; classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort)); serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList, classId); classId.prepend(QVariant::fromValue(uuids.at(i))); serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId); serviceInfo.setServiceName(QBluetoothServiceDiscoveryAgent::tr("Serial Port Profile")); serviceInfo.setServiceUuid(uuids.at(i)); } else if (sppIndex == i && customUuids.isEmpty()) { //set rfcomm protocol QBluetoothServiceInfo::Sequence protocol; protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm)) << QVariant::fromValue(0); protocolDescriptorList.append(QVariant::fromValue(protocol)); QBluetoothServiceInfo::Sequence classId; classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort)); serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList, classId); //also we need to set the custom uuid to the SPP uuid //otherwise QBluetoothSocket::connectToService() would fail due to a missing service uuid serviceInfo.setServiceUuid(uuids.at(i)); } else if (customUuids.contains(i)) { //custom uuid but no serial port serviceInfo.setServiceUuid(uuids.at(i)); } //Check if the UUID is in the uuidFilter if (!uuidFilter.isEmpty() && !uuidFilter.contains(serviceInfo.serviceUuid())) continue; serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList, protocolDescriptorList); serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup)); if (!customUuids.contains(i)) { //if we don't have custom uuid use it as class id as well QBluetoothServiceInfo::Sequence classId; classId << QVariant::fromValue(uuids.at(i)); serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId); QBluetoothUuid::ServiceClassUuid clsId = static_cast<QBluetoothUuid::ServiceClassUuid>(uuids.at(i).toUInt16()); serviceInfo.setServiceName(QBluetoothUuid::serviceClassToString(clsId)); } //don't include the service if we already discovered it before if (!isDuplicatedService(serviceInfo)) { discoveredServices << serviceInfo; //qCDebug(QT_BT_ANDROID) << serviceInfo; emit q->serviceDiscovered(serviceInfo); } } }
void tst_QBluetoothServiceInfo::tst_construction() { const QString serviceName("My Service"); const QString alternateServiceName("Another ServiceName"); const QBluetoothDeviceInfo deviceInfo(QBluetoothAddress("001122334455"), "Test Device", 0); const QBluetoothDeviceInfo alternatedeviceInfo(QBluetoothAddress("554433221100"), "Test Device2", 0); QList<QBluetoothUuid::ProtocolUuid> protUuids; //list taken from qbluetoothuuid.h protUuids << QBluetoothUuid::Sdp; protUuids << QBluetoothUuid::Udp; protUuids << QBluetoothUuid::Rfcomm; protUuids << QBluetoothUuid::Tcp; protUuids << QBluetoothUuid::TcsBin; protUuids << QBluetoothUuid::TcsAt; protUuids << QBluetoothUuid::Att; protUuids << QBluetoothUuid::Obex; protUuids << QBluetoothUuid::Ip; protUuids << QBluetoothUuid::Ftp; protUuids << QBluetoothUuid::Http; protUuids << QBluetoothUuid::Wsp; protUuids << QBluetoothUuid::Bnep; protUuids << QBluetoothUuid::Upnp; protUuids << QBluetoothUuid::Hidp; protUuids << QBluetoothUuid::HardcopyControlChannel; protUuids << QBluetoothUuid::HardcopyDataChannel; protUuids << QBluetoothUuid::HardcopyNotification; protUuids << QBluetoothUuid::Avctp; protUuids << QBluetoothUuid::Avdtp; protUuids << QBluetoothUuid::Cmtp; protUuids << QBluetoothUuid::UdiCPlain; protUuids << QBluetoothUuid::McapControlChannel; protUuids << QBluetoothUuid::McapDataChannel; protUuids << QBluetoothUuid::L2cap; { QBluetoothServiceInfo serviceInfo; QVERIFY(!serviceInfo.isValid()); QVERIFY(!serviceInfo.isComplete()); QVERIFY(!serviceInfo.isRegistered()); QCOMPARE(serviceInfo.serviceName(), QString()); QCOMPARE(serviceInfo.serviceDescription(), QString()); QCOMPARE(serviceInfo.serviceProvider(), QString()); QCOMPARE(serviceInfo.serviceUuid(), QBluetoothUuid()); QCOMPARE(serviceInfo.serviceClassUuids().count(), 0); QCOMPARE(serviceInfo.attributes().count(), 0); QCOMPARE(serviceInfo.serverChannel(), -1); QCOMPARE(serviceInfo.protocolServiceMultiplexer(), -1); foreach (QBluetoothUuid::ProtocolUuid u, protUuids) QCOMPARE(serviceInfo.protocolDescriptor(u).count(), 0); } { QBluetoothServiceInfo serviceInfo; serviceInfo.setServiceName(serviceName); serviceInfo.setDevice(deviceInfo); QVERIFY(serviceInfo.isValid()); QVERIFY(!serviceInfo.isComplete()); QVERIFY(!serviceInfo.isRegistered()); QCOMPARE(serviceInfo.serviceName(), serviceName); QCOMPARE(serviceInfo.device().address(), deviceInfo.address()); QBluetoothServiceInfo copyInfo(serviceInfo); QVERIFY(copyInfo.isValid()); QVERIFY(!copyInfo.isComplete()); QVERIFY(!copyInfo.isRegistered()); QCOMPARE(copyInfo.serviceName(), serviceName); QCOMPARE(copyInfo.device().address(), deviceInfo.address()); copyInfo.setAttribute(QBluetoothServiceInfo::ServiceName, alternateServiceName); copyInfo.setDevice(alternatedeviceInfo); QCOMPARE(copyInfo.serviceName(), alternateServiceName); QCOMPARE(copyInfo.attribute(QBluetoothServiceInfo::ServiceName).toString(), alternateServiceName); QCOMPARE(serviceInfo.serviceName(), alternateServiceName); QCOMPARE(copyInfo.device().address(), alternatedeviceInfo.address()); QCOMPARE(serviceInfo.device().address(), alternatedeviceInfo.address()); foreach (QBluetoothUuid::ProtocolUuid u, protUuids) QCOMPARE(serviceInfo.protocolDescriptor(u).count(), 0); foreach (QBluetoothUuid::ProtocolUuid u, protUuids) QCOMPARE(copyInfo.protocolDescriptor(u).count(), 0); } }
void Tennis::serviceDiscovered(const QBluetoothServiceInfo &serviceInfo) { qDebug() << "***** Discovered! " << serviceInfo.device().name() << serviceInfo.serviceName() << serviceInfo.serviceUuid(); qDebug() << "Found one!" << serviceInfo.protocolServiceMultiplexer(); m_discoveryAgent->stop(); client->startClient(serviceInfo); QSettings settings("QtDF", "bttennis"); settings.setValue("lastclient", serviceInfo.device().address().toString()); }