/*!
Attempts to make a connection to the service identified by \a uuid on the device with address
\a address.
The socket is opened in the given \a openMode.
For BlueZ, the socket first enters the \l ServiceLookupState and queries the connection parameters for
\a uuid. If the service parameters are successfully retrieved the socket enters
ConnectingState, and attempts to connect to \a address. If a connection is established,
QBluetoothSocket enters Connected State and emits connected().
On BlackBerry and Android, the service connection can directly be established
using the UUID of the remote service. Therefore these platforms do not require
the \l ServiceLookupState and \l socketType() is always set to
\l QBluetoothServiceInfo::RfcommProtocol.
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 QBluetoothAddress &address, const QBluetoothUuid &uuid, OpenMode openMode)
{
Q_D(QBluetoothSocket);
if (state() != QBluetoothSocket::UnconnectedState) {
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(QBluetoothServiceInfo::RfcommProtocol)) {
d->errorString = tr("Socket type not supported");
setSocketError(QBluetoothSocket::UnsupportedProtocolError);
return;
}
d->connectToService(address, uuid, openMode);
#else
QBluetoothServiceInfo service;
QBluetoothDeviceInfo device(address, QString(), QBluetoothDeviceInfo::MiscellaneousDevice);
service.setDevice(device);
service.setServiceUuid(uuid);
doDeviceDiscovery(service, openMode);
#endif
}
static PyObject *meth_QBluetoothServiceInfo_registerService(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
PyObject *sipParseErr = NULL;
{
const QBluetoothAddress& a0def = QBluetoothAddress();
const QBluetoothAddress* a0 = &a0def;
QBluetoothServiceInfo *sipCpp;
static const char *sipKwdList[] = {
sipName_localAdapter,
};
if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, sipType_QBluetoothAddress, &a0))
{
bool sipRes;
sipRes = sipCpp->registerService(*a0);
return PyBool_FromLong(sipRes);
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_registerService, doc_QBluetoothServiceInfo_registerService);
return NULL;
}
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);
}
//! [Connect to remote service]
void Chat::connectClicked()
{
ui->connectButton->setEnabled(false);
// scan for services
const QBluetoothAddress adapter = localAdapters.isEmpty() ?
QBluetoothAddress() :
localAdapters.at(currentAdapterIndex).address();
RemoteSelector remoteSelector(adapter);
remoteSelector.startDiscovery(QBluetoothUuid(serviceUuid));
if (remoteSelector.exec() == QDialog::Accepted) {
QBluetoothServiceInfo service = remoteSelector.service();
qDebug() << "Connecting to service 2" << service.serviceName()
<< "on" << service.device().name();
// Create client
qDebug() << "Going to create client";
ChatClient *client = new ChatClient(this);
qDebug() << "Connecting...";
connect(client, SIGNAL(messageReceived(QString,QString)),
this, SLOT(showMessage(QString,QString)));
connect(client, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
connect(client, SIGNAL(connected(QString)), this, SLOT(connected(QString)));
connect(this, SIGNAL(sendMessage(QString)), client, SLOT(sendMessage(QString)));
qDebug() << "Start client";
client->startClient(service);
clients.append(client);
}
ui->connectButton->setEnabled(true);
}
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());
}
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 tst_QBluetoothServiceInfo::tst_construction()
{
const QString serviceName("My Service");
const QBluetoothDeviceInfo deviceInfo(QBluetoothAddress("001122334455"), "Test Device", 0);
{
QBluetoothServiceInfo serviceInfo;
QVERIFY(!serviceInfo.isValid());
QVERIFY(!serviceInfo.isComplete());
}
{
QBluetoothServiceInfo serviceInfo;
serviceInfo.setServiceName(serviceName);
serviceInfo.setDevice(deviceInfo);
QVERIFY(serviceInfo.isValid());
QCOMPARE(serviceInfo.serviceName(), serviceName);
QCOMPARE(serviceInfo.device().address(), deviceInfo.address());
QBluetoothServiceInfo copyInfo(serviceInfo);
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.serviceName(), serviceName);
QCOMPARE(copyInfo.device().address(), deviceInfo.address());
}
}
void QBluetoothSocket::serviceDiscovered(const QBluetoothServiceInfo &service)
{
Q_D(QBluetoothSocket);
qCDebug(QT_BT) << "FOUND SERVICE!" << service;
if (service.protocolServiceMultiplexer() > 0 || service.serverChannel() > 0) {
connectToService(service, d->openMode);
d->discoveryAgent->deleteLater();
d->discoveryAgent = 0;
} else {
qCDebug(QT_BT) << "Could not find port/psm for potential remote service";
}
}
void RemoteSelector::pairingFinished(const QBluetoothAddress &address, QBluetoothLocalDevice::Pairing status)
{
QBluetoothServiceInfo service;
int row = 0;
ui->pairingBusy->hide();
ui->pairingBusy->movie()->stop();
ui->remoteDevices->blockSignals(true);
for(int i = 0; i < m_discoveredServices.count(); i++){
if(m_discoveredServices.value(i).device().address() == address){
service = m_discoveredServices.value(i);
row = i;
break;
}
}
if(m_pindisplay)
delete m_pindisplay;
QMessageBox msgBox;
if(status == QBluetoothLocalDevice::Paired ||
status == QBluetoothLocalDevice::AuthorizedPaired){
msgBox.setText("Paired successfully with" + address.toString());
}
else {
msgBox.setText("Pairing failed with " + address.toString());
}
if(service.isValid()){
if(status == QBluetoothLocalDevice::AuthorizedPaired){
ui->remoteDevices->item(row, 3)->setCheckState(Qt::Checked);
ui->remoteDevices->item(row, 4)->setCheckState(Qt::Checked);
}
else if(status == QBluetoothLocalDevice::Paired){
ui->remoteDevices->item(row, 3)->setCheckState(Qt::Checked);
ui->remoteDevices->item(row, 4)->setCheckState(Qt::Unchecked);
}
else {
ui->remoteDevices->item(row, 3)->setCheckState(Qt::Unchecked);
ui->remoteDevices->item(row, 4)->setCheckState(Qt::Unchecked);
}
}
msgBox.exec();
ui->remoteDevices->blockSignals(false);
}
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;
}
/*!
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
}
int QDeclarativeBluetoothServicePrivate::listen() {
if (m_service->socketProtocol() == QBluetoothServiceInfo::UnknownProtocol) {
qWarning() << "Unknown protocol, can't make service" << m_protocol;
return -1;
}
QBluetoothServiceInfo::Protocol serverType = QBluetoothServiceInfo::UnknownProtocol;
if (m_service->socketProtocol() == QBluetoothServiceInfo::L2capProtocol)
serverType = QBluetoothServiceInfo::L2capProtocol;
else if (m_service->socketProtocol() == QBluetoothServiceInfo::RfcommProtocol)
serverType = QBluetoothServiceInfo::RfcommProtocol;
QBluetoothServer *server = new QBluetoothServer(serverType);
server->setMaxPendingConnections(1);
server->listen(QBluetoothAddress());
server->serverPort();
m_server = server;
return server->serverPort();
}
void tst_QBluetoothServiceInfo::tst_serviceClassUuids()
{
QBluetoothServiceInfo info;
QCOMPARE(info.serviceClassUuids().count(), 0);
QBluetoothServiceInfo::Sequence classIds;
classIds << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort));
QCOMPARE(classIds.count(), 1);
QBluetoothUuid uuid(QString("e8e10f95-1a70-4b27-9ccf-02010264e9c8"));
classIds.prepend(QVariant::fromValue(uuid));
QCOMPARE(classIds.count(), 2);
QCOMPARE(classIds.at(0).value<QBluetoothUuid>(), uuid);
info.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classIds);
QList<QBluetoothUuid> svclids = info.serviceClassUuids();
QCOMPARE(svclids.count(), 2);
QCOMPARE(svclids.at(0), uuid);
QCOMPARE(svclids.at(1), QBluetoothUuid(QBluetoothUuid::SerialPort));
}
static PyObject *meth_QBluetoothServiceInfo_setServiceAvailability(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
quint8 a0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BM", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, &a0))
{
sipCpp->setServiceAvailability(a0);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_setServiceAvailability, doc_QBluetoothServiceInfo_setServiceAvailability);
return NULL;
}
static PyObject *meth_QBluetoothServiceInfo_setServiceUuid(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QBluetoothUuid* a0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, sipType_QBluetoothUuid, &a0))
{
sipCpp->setServiceUuid(*a0);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_setServiceUuid, doc_QBluetoothServiceInfo_setServiceUuid);
return NULL;
}
static PyObject *meth_QBluetoothServiceInfo_removeAttribute(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
quint16 a0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "Bt", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, &a0))
{
sipCpp->removeAttribute(a0);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_removeAttribute, doc_QBluetoothServiceInfo_removeAttribute);
return NULL;
}
void Tennis::nearFieldHandover()
{
qDebug() << "Connecting to NFC provided address" << m_handover->bluetoothAddress().toString();
QBluetoothDeviceInfo device = QBluetoothDeviceInfo(m_handover->bluetoothAddress(), QString(),
QBluetoothDeviceInfo::ComputerDevice);
QBluetoothServiceInfo service;
service.setServiceUuid(QBluetoothUuid(serviceUuid));
service.setDevice(device);
QBluetoothServiceInfo::Sequence protocolDescriptorList;
QBluetoothServiceInfo::Sequence protocol;
protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::L2cap))
<< QVariant::fromValue(m_handover->serverPort());
protocolDescriptorList.append(QVariant::fromValue(protocol));
service.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList,
protocolDescriptorList);
client->startClient(service);
board->setStatus(tr("Connecting: %1 %2").arg(m_handover->bluetoothAddress().toString()).arg(m_handover->serverPort()), 100, 25);
}
static PyObject *meth_QBluetoothServiceInfo_unregisterService(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp))
{
bool sipRes;
sipRes = sipCpp->unregisterService();
return PyBool_FromLong(sipRes);
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_unregisterService, doc_QBluetoothServiceInfo_unregisterService);
return NULL;
}
void LiveViewScanner::handleDiscoveredService(const QBluetoothServiceInfo &info)
{
const QBluetoothDeviceInfo dev = info.device();
QString deviceName = dev.name();
if (deviceName == "LiveView") {
QVariantMap foundInfo;
foundInfo["driver"] = QString("liveview");
foundInfo["address"] = dev.address().toString();
foundInfo["name"] = deviceName;
foundInfo["notification-watchlet"] = QString("com.javispedro.sowatch.liveview.notification");
emit watchFound(foundInfo);
}
}
void iControlPadClient::serviceDiscovered(const QBluetoothServiceInfo &serviceInfo)
{
qDebug() << "Discovered service on"
<< serviceInfo.device().name() << serviceInfo.device().address().toString();
qDebug() << "\tService name:" << serviceInfo.serviceName();
qDebug() << "\tDescription:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceDescription).toString();
qDebug() << "\tProvider:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceProvider).toString();
qDebug() << "\tL2CAP protocol service multiplexer:"
<< serviceInfo.protocolServiceMultiplexer();
qDebug() << "\tRFCOMM server channel:" << serviceInfo.serverChannel();
if( QString::compare ( serviceInfo.serviceName(), KiCPServiceName, Qt::CaseInsensitive ) == 0 )
connectToService( serviceInfo );
}
QVariant QDeclarativeBluetoothDiscoveryModel::data(const QModelIndex &index, int role) const
{
QDeclarativeBluetoothService *service = d->m_services.value(index.row());
QBluetoothServiceInfo *info = service->serviceInfo();
switch(role) {
case Qt::DisplayRole:
{
QString label = info->device().name();
if(label.isEmpty())
label += info->device().address().toString();
label += " " + info->serviceName();
return label;
}
case Qt::DecorationRole:
return QLatin1String("image://bluetoothicons/default");
case ServiceRole:
{
return QVariant::fromValue(service);
}
}
return QVariant();
}
static PyObject *meth_QBluetoothServiceInfo_setServiceProvider(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QString* a0;
int a0State = 0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, sipType_QString,&a0, &a0State))
{
sipCpp->setServiceProvider(*a0);
sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_setServiceProvider, doc_QBluetoothServiceInfo_setServiceProvider);
return NULL;
}
static PyObject *meth_QBluetoothServiceInfo_setAttribute(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
quint16 a0;
const QBluetoothUuid* a1;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BtJ9", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, &a0, sipType_QBluetoothUuid, &a1))
{
sipCpp->setAttribute(a0,*a1);
Py_INCREF(Py_None);
return Py_None;
}
}
{
quint16 a0;
const QBluetoothServiceInfo::Sequence* a1;
int a1State = 0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BtJ1", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, &a0, sipType_QBluetoothServiceInfo_Sequence,&a1, &a1State))
{
sipCpp->setAttribute(a0,*a1);
sipReleaseType(const_cast<QBluetoothServiceInfo::Sequence *>(a1),sipType_QBluetoothServiceInfo_Sequence,a1State);
Py_INCREF(Py_None);
return Py_None;
}
}
{
quint16 a0;
const QVariant* a1;
int a1State = 0;
QBluetoothServiceInfo *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BtJ1", &sipSelf, sipType_QBluetoothServiceInfo, &sipCpp, &a0, sipType_QVariant, &a1, &a1State))
{
sipCpp->setAttribute(a0,*a1);
sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBluetoothServiceInfo, sipName_setAttribute, doc_QBluetoothServiceInfo_setAttribute);
return NULL;
}
void ServiceDiscoveryDialog::addService(const QBluetoothServiceInfo &info)
{
if (info.serviceName().isEmpty())
return;
QString line = info.serviceName();
if (!info.serviceDescription().isEmpty())
line.append("\n\t" + info.serviceDescription());
if (!info.serviceProvider().isEmpty())
line.append("\n\t" + info.serviceProvider());
ui->list->addItem(line);
}
void MetaWatchScanner::handleDiscoveredService(const QBluetoothServiceInfo &info)
{
const QBluetoothDeviceInfo dev = info.device();
QString deviceName = dev.name();
if (deviceName.startsWith("MetaWatch")) {
QVariantMap foundInfo;
foundInfo["address"] = dev.address().toString();
foundInfo["name"] = deviceName;
qDebug() << "metawatch bluetooth scan found:" << deviceName;
if (deviceName.contains("Analog")) {
// This is Analog metawatch.
foundInfo["driver"] = QString("metawatch-analog");
emit watchFound(foundInfo);
} else {
// For now, assume Digital metawatch.
foundInfo["driver"] = QString("metawatch-digital");
foundInfo["idle-watchlet"] = QString("com.javispedro.sowatch.metawatch.watchface");
foundInfo["notification-watchlet"] = QString("com.javispedro.sowatch.metawatch.notification");
emit watchFound(foundInfo);
}
}
}
void tst_QBluetoothServiceInfo::tst_assignment()
{
QFETCH(QUuid, uuid);
QFETCH(QBluetoothUuid::ProtocolUuid, protocolUuid);
QFETCH(QBluetoothServiceInfo::Protocol, serviceInfoProtocol);
const QString serviceName("My Service");
const QBluetoothDeviceInfo deviceInfo(QBluetoothAddress("001122334455"), "Test Device", 0);
QBluetoothServiceInfo serviceInfo;
serviceInfo.setServiceName(serviceName);
serviceInfo.setDevice(deviceInfo);
QVERIFY(serviceInfo.isValid());
{
QBluetoothServiceInfo copyInfo = serviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.serviceName(), serviceName);
QCOMPARE(copyInfo.device().address(), deviceInfo.address());
}
{
QBluetoothServiceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = serviceInfo;
QVERIFY(copyInfo.isValid());
QCOMPARE(copyInfo.serviceName(), serviceName);
QCOMPARE(copyInfo.device().address(), deviceInfo.address());
}
{
QBluetoothServiceInfo copyInfo1;
QBluetoothServiceInfo copyInfo2;
QVERIFY(!copyInfo1.isValid());
QVERIFY(!copyInfo2.isValid());
copyInfo1 = copyInfo2 = serviceInfo;
QVERIFY(copyInfo1.isValid());
QVERIFY(copyInfo2.isValid());
QCOMPARE(copyInfo1.serviceName(), serviceName);
QCOMPARE(copyInfo2.serviceName(), serviceName);
QCOMPARE(copyInfo1.device().address(), deviceInfo.address());
QCOMPARE(copyInfo2.device().address(), deviceInfo.address());
}
{
QBluetoothServiceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = serviceInfo;
copyInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList, uuid);
QVERIFY(copyInfo.contains(QBluetoothServiceInfo::ProtocolDescriptorList));
QVERIFY(copyInfo.isComplete());
QVERIFY(copyInfo.attributes().count() > 0);
copyInfo.removeAttribute(QBluetoothServiceInfo::ProtocolDescriptorList);
QVERIFY(!copyInfo.contains(QBluetoothServiceInfo::ProtocolDescriptorList));
QVERIFY(!copyInfo.isComplete());
}
{
QBluetoothServiceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = serviceInfo;
QVERIFY(copyInfo.serverChannel() == -1);
QVERIFY(copyInfo.protocolServiceMultiplexer() == -1);
QBluetoothServiceInfo::Sequence protocolDescriptorList;
QBluetoothServiceInfo::Sequence protocol;
protocol << QVariant::fromValue(QBluetoothUuid(protocolUuid));
protocolDescriptorList.append(QVariant::fromValue(protocol));
protocol.clear();
protocolDescriptorList.append(QVariant::fromValue(protocol));
copyInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList,
protocolDescriptorList);
QVERIFY(copyInfo.serverChannel() == -1);
QVERIFY(copyInfo.protocolServiceMultiplexer() != -1);
QVERIFY(copyInfo.socketProtocol() == serviceInfoProtocol);
}
{
QBluetoothServiceInfo copyInfo;
QVERIFY(!copyInfo.isValid());
copyInfo = serviceInfo;
QVERIFY(!copyInfo.isRegistered());
QVERIFY(copyInfo.registerService());
QVERIFY(copyInfo.isRegistered());
QVERIFY(copyInfo.unregisterService());
QVERIFY(!copyInfo.isRegistered());
}
}
void RemoteSelector::serviceDiscovered(const QBluetoothServiceInfo& serviceInfo) {
#if DEBUG_OUTPUT
qDebug() << "Discovered service on"
<< serviceInfo.device().name() << serviceInfo.device().address().toString();
qDebug() << "\tService name:" << serviceInfo.serviceName();
qDebug() << "\tDescription:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceDescription).toString();
qDebug() << "\tProvider:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceProvider).toString();
qDebug() << "\tL2CAP protocol service multiplexer:"
<< serviceInfo.protocolServiceMultiplexer();
qDebug() << "\tRFCOMM server channel:" << serviceInfo.serverChannel();
#endif
QString remoteName;
if (serviceInfo.device().name().isEmpty())
remoteName = serviceInfo.device().address().toString();
else
remoteName = serviceInfo.device().name();
QMutableMapIterator<int, QBluetoothServiceInfo> i(discoveredServices_);
while (i.hasNext()){
i.next();
if (serviceInfo.device().address() == i.value().device().address()){
i.setValue(serviceInfo);
return;
}
}
QString tooltip = QString("address: %1\nname: %2\nis trusted: %3\nis valid: %4\nservice: %5").arg(
serviceInfo.device().address().toString(),
serviceInfo.device().name(),
trustedDevicelist.isTrusted(serviceInfo.device().address().toString()) ? "yes" : "no",
serviceInfo.device().isValid() ? "yes" : "no",
serviceInfo.serviceDescription());
if (!trustedDevicelist.isTrusted(serviceInfo.device().address().toString()))
{
int row = ui->remoteDevices->rowCount();
ui->remoteDevices->insertRow(row);
QTableWidgetItem *item = new QTableWidgetItem(serviceInfo.device().address().toString());
item->setToolTip(tooltip);
ui->remoteDevices->setItem(row, 0, item);
item = new QTableWidgetItem(serviceInfo.device().name());
ui->remoteDevices->setItem(row, 1, item);
item = new QTableWidgetItem(serviceInfo.serviceName());
ui->remoteDevices->setItem(row, 2, item);
QBluetoothLocalDevice::Pairing p;
p = localDevice_->pairingStatus(serviceInfo.device().address());
ui->remoteDevices->blockSignals(true);
item = new QTableWidgetItem();
if ((p&QBluetoothLocalDevice::Paired) || (p&QBluetoothLocalDevice::AuthorizedPaired))
item->setCheckState(Qt::Checked);
else
item->setCheckState(Qt::Unchecked);
ui->remoteDevices->setItem(row, 3, item);
item = new QTableWidgetItem();
if (p&QBluetoothLocalDevice::AuthorizedPaired)
item->setCheckState(Qt::Checked);
else
item->setCheckState(Qt::Unchecked);
ui->remoteDevices->setItem(row, 4, item);
item = new QTableWidgetItem();
if (trustedDevicelist.isTrusted(serviceInfo.device().address().toString()))
item->setCheckState(Qt::Checked);
else
item->setCheckState(Qt::Unchecked);
ui->remoteDevices->setItem(row, 5, item);
ui->remoteDevices->blockSignals(false);
discoveredServices_.insert(row, serviceInfo);
}
}
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 RemoteSelector::serviceDiscovered(const QBluetoothServiceInfo &serviceInfo)
{
#if 0
qDebug() << "Discovered service on"
<< serviceInfo.device().name() << serviceInfo.device().address().toString();
qDebug() << "\tService name:" << serviceInfo.serviceName();
qDebug() << "\tDescription:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceDescription).toString();
qDebug() << "\tProvider:"
<< serviceInfo.attribute(QBluetoothServiceInfo::ServiceProvider).toString();
qDebug() << "\tL2CAP protocol service multiplexer:"
<< serviceInfo.protocolServiceMultiplexer();
qDebug() << "\tRFCOMM server channel:" << serviceInfo.serverChannel();
#endif
QMapIterator<QListWidgetItem *, QBluetoothServiceInfo> i(m_discoveredServices);
while (i.hasNext()){
i.next();
if (serviceInfo.device().address() == i.value().device().address()){
return;
}
}
QString remoteName;
if (serviceInfo.device().name().isEmpty())
remoteName = serviceInfo.device().address().toString();
else
remoteName = serviceInfo.device().name();
QListWidgetItem *item =
new QListWidgetItem(QString::fromLatin1("%1 %2").arg(remoteName,
serviceInfo.serviceName()));
m_discoveredServices.insert(item, serviceInfo);
ui->remoteDevices->addItem(item);
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
RfCommClient client;
QBluetoothLocalDevice localDevice;
MyThread mythread;
QObject::connect(&client, SIGNAL(done()), &app, SLOT(quit()));
QString address;
QString port;
QStringList args = QCoreApplication::arguments();
if(args.length() >= 2){
address = args.at(1);
if(args.length() >= 3){
port = args.at(2);
}
}
// use previous value for client, stored earlier
// if(address.isEmpty()){
// QSettings settings("QtDF", "bttennis");
// address = settings.value("lastclient").toString();
// }
// hard-code address and port number if not provided
if(address.isEmpty()){
address = "6C:9B:02:0C:91:D3"; // "J C7-2"
port = QString("20");
}
if(!address.isEmpty()){
qDebug() << "Connecting to" << address << port;
QBluetoothDeviceInfo device = QBluetoothDeviceInfo(QBluetoothAddress(address), "",
QBluetoothDeviceInfo::MiscellaneousDevice);
QBluetoothServiceInfo service;
if (!port.isEmpty()) {
QBluetoothServiceInfo::Sequence protocolDescriptorList;
QBluetoothServiceInfo::Sequence protocol;
protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm))
<< QVariant::fromValue(port.toUShort());
protocolDescriptorList.append(QVariant::fromValue(protocol));
service.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList,
protocolDescriptorList);
qDebug() << "port" << port.toUShort() << service.protocolServiceMultiplexer();
}
else {
service.setServiceUuid(QBluetoothUuid(serviceUuid));
}
service.setDevice(device);
// delay so that server is in waiting state
qDebug() << "Starting sleep";
mythread.sleep(10); // seconds
qDebug() << "Finished sleeping";
client.startClient(service);
} else {
qDebug() << "failed because address and/or port is missing " << address << port;
}
return app.exec();
}