Revision control
Copy as Markdown
// Copyright (C) 2016 Lauri Laanmets (Proekspert AS) <lauri.laanmets@eesti.ee>
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qbluetoothsocket.h"
#include "qbluetoothsocket_android_p.h"
#include "qbluetoothaddress.h"
#include "qbluetoothdeviceinfo.h"
#include "qbluetoothserviceinfo.h"
#include "android/androidutils_p.h"
#include "android/jni_android_p.h"
#include <QCoreApplication>
#include <QtCore/QLoggingCategory>
#include <QtCore/QThread>
#include <QtCore/QTime>
#include <QtCore/QJniEnvironment>
#include <QtCore/q26numeric.h>
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)
#define USE_FALLBACK true
Q_BLUETOOTH_EXPORT bool useReverseUuidWorkAroundConnect = true;
/* BluetoothSocket.connect() can block up to 10s. Therefore it must be
* in a separate thread. Unfortunately if BluetoothSocket.close() is
* called while connect() is still blocking the resulting behavior is not reliable.
* This may well be an Android platform bug. In any case, close() must
* be queued up until connect() has returned.
*
* The WorkerThread manages the connect() and close() calls. Interaction
* with the main thread happens via signals and slots. There is an accepted but
* undesirable side effect of this approach as the user may call connect()
* and close() and the socket would continue to successfully connect to
* the remote device just to immidiately close the physical connection again.
*
* WorkerThread and SocketConnectWorker are cleaned up via the threads
* finished() signal.
*/
class SocketConnectWorker : public QObject
{
Q_OBJECT
public:
SocketConnectWorker(const QJniObject& socket,
const QJniObject& targetUuid,
const QBluetoothUuid& qtTargetUuid)
: QObject(),
mSocketObject(socket),
mTargetUuid(targetUuid),
mQtTargetUuid(qtTargetUuid)
{
static int t = qRegisterMetaType<QJniObject>();
Q_UNUSED(t);
}
signals:
void socketConnectDone(const QJniObject &socket);
void socketConnectFailed(const QJniObject &socket,
const QJniObject &targetUuid,
const QBluetoothUuid &qtUuid);
public slots:
void connectSocket()
{
QJniEnvironment env;
qCDebug(QT_BT_ANDROID) << "Connecting socket";
auto methodId = env.findMethod(mSocketObject.objectClass(), "connect", "()V");
if (methodId)
env->CallVoidMethod(mSocketObject.object(), methodId);
if (!methodId || env.checkAndClearExceptions()) {
emit socketConnectFailed(mSocketObject, mTargetUuid, mQtTargetUuid);
QThread::currentThread()->quit();
return;
}
qCDebug(QT_BT_ANDROID) << "Socket connection established";
emit socketConnectDone(mSocketObject);
}
void closeSocket()
{
qCDebug(QT_BT_ANDROID) << "Executing queued closeSocket()";
mSocketObject.callMethod<void>("close");
QThread::currentThread()->quit();
}
private:
QJniObject mSocketObject;
QJniObject mTargetUuid;
// same as mTargetUuid above - just the Qt C++ version rather than jni uuid
QBluetoothUuid mQtTargetUuid;
};
class WorkerThread: public QThread
{
Q_OBJECT
public:
WorkerThread()
: QThread(), workerPointer(0)
{
}
// Runs in same thread as QBluetoothSocketPrivateAndroid
void setupWorker(QBluetoothSocketPrivateAndroid* d_ptr, const QJniObject& socketObject,
const QJniObject& uuidObject, bool useFallback,
const QBluetoothUuid& qtUuid = QBluetoothUuid())
{
SocketConnectWorker* worker = new SocketConnectWorker(
socketObject, uuidObject, qtUuid);
worker->moveToThread(this);
connect(this, &QThread::finished, worker, &QObject::deleteLater);
connect(this, &QThread::finished, this, &QObject::deleteLater);
connect(d_ptr, &QBluetoothSocketPrivateAndroid::connectJavaSocket,
worker, &SocketConnectWorker::connectSocket);
connect(d_ptr, &QBluetoothSocketPrivateAndroid::closeJavaSocket,
worker, &SocketConnectWorker::closeSocket);
connect(worker, &SocketConnectWorker::socketConnectDone,
d_ptr, &QBluetoothSocketPrivateAndroid::socketConnectSuccess);
if (useFallback) {
connect(worker, &SocketConnectWorker::socketConnectFailed,
d_ptr, &QBluetoothSocketPrivateAndroid::fallbackSocketConnectFailed);
} else {
connect(worker, &SocketConnectWorker::socketConnectFailed,
d_ptr, &QBluetoothSocketPrivateAndroid::defaultSocketConnectFailed);
}
workerPointer = worker;
}
private:
QPointer<SocketConnectWorker> workerPointer;
};
QBluetoothSocketPrivateAndroid::QBluetoothSocketPrivateAndroid(QBluetoothSocket *qq)
: QBluetoothSocketBasePrivate{qq},
inputThread(0)
{
secFlags = QBluetooth::Security::Secure;
adapter = getDefaultBluetoothAdapter();
qRegisterMetaType<QBluetoothSocket::SocketError>();
qRegisterMetaType<QBluetoothSocket::SocketState>();
}
QBluetoothSocketPrivateAndroid::~QBluetoothSocketPrivateAndroid()
{
if (state != QBluetoothSocket::SocketState::UnconnectedState)
emit closeJavaSocket();
}
bool QBluetoothSocketPrivateAndroid::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
{
socketType = type;
if (socketType == QBluetoothServiceInfo::RfcommProtocol)
return true;
return false;
}
/*
* Workaround for QTBUG-61392. If the underlying Android bug gets fixed,
* we need to consider restoring the non-reversed fallbackConnect from the repository.
*/
bool QBluetoothSocketPrivateAndroid::fallBackReversedConnect(const QBluetoothUuid &uuid)
{
Q_Q(QBluetoothSocket);
qCWarning(QT_BT_ANDROID) << "Falling back to reverse uuid workaround.";
const QBluetoothUuid reverse = reverseUuid(uuid);
if (reverse.isNull())
return false;
QString tempUuid = reverse.toString(QUuid::WithoutBraces);
QJniEnvironment env;
const QJniObject inputString = QJniObject::fromString(tempUuid);
const QJniObject uuidObject = QJniObject::callStaticMethod<QtJniTypes::UUID>(
QtJniTypes::Traits<QtJniTypes::UUID>::className(), "fromString",
inputString.object<jstring>());
if (secFlags == QBluetooth::SecurityFlags(QBluetooth::Security::NoSecurity)) {
qCDebug(QT_BT_ANDROID) << "Connecting via insecure rfcomm";
socketObject = remoteDevice.callMethod<QtJniTypes::BluetoothSocket>(
"createInsecureRfcommSocketToServiceRecord",
uuidObject.object<QtJniTypes::UUID>());
} else {
qCDebug(QT_BT_ANDROID) << "Connecting via secure rfcomm";
socketObject = remoteDevice.callMethod<QtJniTypes::BluetoothSocket>(
"createRfcommSocketToServiceRecord",
uuidObject.object<QtJniTypes::UUID>());
}
if (!socketObject.isValid()) {
remoteDevice = QJniObject();
errorString = QBluetoothSocket::tr("Cannot connect to %1",
"%1 = uuid").arg(reverse.toString());
q->setSocketError(QBluetoothSocket::SocketError::ServiceNotFoundError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return false;
}
WorkerThread *workerThread = new WorkerThread();
workerThread->setupWorker(this, socketObject, uuidObject, USE_FALLBACK);
workerThread->start();
emit connectJavaSocket();
return true;
}
/*
* The call order during a connectToServiceHelper() is as follows:
*
* 1. call connectToServiceHelper()
* 2. wait for execution of SocketConnectThread::run()
* 3. if threaded connect succeeds call socketConnectSuccess() via signals
* -> done
* 4. if threaded connect fails call defaultSocketConnectFailed() via signals
* 5. call fallBackReversedConnect()
* -> if failure entire connectToServiceHelper() fails
* Note: This fallback can be disabled with private API boolean
* 6. if threaded connect on one of above fallbacks succeeds call socketConnectSuccess()
* via signals
* -> done
* 7. if threaded connect on fallback channel fails call fallbackSocketConnectFailed()
* -> complete failure of entire connectToServiceHelper()
* */
void QBluetoothSocketPrivateAndroid::connectToServiceHelper(const QBluetoothAddress &address,
const QBluetoothUuid &uuid,
QIODevice::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
Q_UNUSED(openMode);
qCDebug(QT_BT_ANDROID) << "connectToServiceHelper()" << address.toString() << uuid.toString();
if (!ensureAndroidPermission(QBluetoothPermission::Access)) {
qCWarning(QT_BT_ANDROID) << "Bluetooth socket connect failed due to missing permissions";
errorString = QBluetoothSocket::tr(
"Bluetooth socket connect failed due to missing permissions.");
q->setSocketError(QBluetoothSocket::SocketError::MissingPermissionsError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
q->setSocketState(QBluetoothSocket::SocketState::ConnectingState);
if (!adapter.isValid()) {
qCWarning(QT_BT_ANDROID) << "Device does not support Bluetooth";
errorString = QBluetoothSocket::tr("Device does not support Bluetooth");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
const int state = adapter.callMethod<jint>("getState");
if (state != 12 ) { //BluetoothAdapter.STATE_ON
qCWarning(QT_BT_ANDROID) << "Bluetooth device offline";
errorString = QBluetoothSocket::tr("Device is powered off");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
QJniEnvironment env;
QJniObject inputString = QJniObject::fromString(address.toString());
remoteDevice = adapter.callMethod<QtJniTypes::BluetoothDevice>("getRemoteDevice",
inputString.object<jstring>());
if (!remoteDevice.isValid()) {
errorString = QBluetoothSocket::tr("Cannot access address %1", "%1 = Bt address e.g. 11:22:33:44:55:66").arg(address.toString());
q->setSocketError(QBluetoothSocket::SocketError::HostNotFoundError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
//cut leading { and trailing } {xxx-xxx}
const QString tempUuid = uuid.toString(QUuid::WithoutBraces);
inputString = QJniObject::fromString(tempUuid);
const QJniObject uuidObject = QJniObject::callStaticMethod<QtJniTypes::UUID>(
QtJniTypes::Traits<QtJniTypes::UUID>::className(), "fromString",
inputString.object<jstring>());
if (secFlags == QBluetooth::SecurityFlags(QBluetooth::Security::NoSecurity)) {
qCDebug(QT_BT_ANDROID) << "Connecting via insecure rfcomm";
socketObject = remoteDevice.callMethod<QtJniTypes::BluetoothSocket>(
"createInsecureRfcommSocketToServiceRecord",
uuidObject.object<QtJniTypes::UUID>());
} else {
qCDebug(QT_BT_ANDROID) << "Connecting via secure rfcomm";
socketObject = remoteDevice.callMethod<QtJniTypes::BluetoothSocket>(
"createRfcommSocketToServiceRecord",
uuidObject.object<QtJniTypes::UUID>());
}
if (!socketObject.isValid()) {
remoteDevice = QJniObject();
errorString = QBluetoothSocket::tr("Cannot connect to %1 on %2",
"%1 = uuid, %2 = Bt address").arg(uuid.toString()).arg(address.toString());
q->setSocketError(QBluetoothSocket::SocketError::ServiceNotFoundError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
WorkerThread *workerThread = new WorkerThread();
workerThread->setupWorker(this, socketObject, uuidObject, !USE_FALLBACK, uuid);
workerThread->start();
emit connectJavaSocket();
}
void QBluetoothSocketPrivateAndroid::connectToService(
const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
if (q->state() != QBluetoothSocket::SocketState::UnconnectedState
&& q->state() != QBluetoothSocket::SocketState::ServiceLookupState) {
qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService called on busy socket";
errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
q->setSocketError(QBluetoothSocket::SocketError::OperationError);
return;
}
// Workaround for QTBUG-75035
/* Not all Android devices publish or discover the SPP uuid for serial services.
* Also, Android does not permit the detection of the protocol used by a serial
* Bluetooth connection.
*
* Therefore, QBluetoothServiceDiscoveryAgentPrivate::populateDiscoveredServices()
* may have to guess what protocol a potential custom uuid uses. The guessing works
* reasonably well as long as the SDP discovery finds the SPP uuid. Otherwise
* the SPP and rfcomm protocol info is missing in \a service.
*
* Android only supports RFCOMM (no L2CP). We assume (in favor of user experience)
* that a non-RFCOMM protocol implies a missing SPP uuid during discovery but the user
* still wanting to connect with the given \a service instance.
*/
auto protocol = service.socketProtocol();
switch (protocol) {
case QBluetoothServiceInfo::L2capProtocol:
case QBluetoothServiceInfo::UnknownProtocol:
qCWarning(QT_BT_ANDROID) << "Changing socket protocol to RFCOMM";
protocol = QBluetoothServiceInfo::RfcommProtocol;
break;
case QBluetoothServiceInfo::RfcommProtocol:
break;
}
if (!ensureNativeSocket(protocol)) {
errorString = QBluetoothSocket::tr("Socket type not supported");
q->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
return;
}
connectToServiceHelper(service.device().address(), service.serviceUuid(), openMode);
}
void QBluetoothSocketPrivateAndroid::connectToService(
const QBluetoothAddress &address, const QBluetoothUuid &uuid,
QIODevice::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
if (q->state() != QBluetoothSocket::SocketState::UnconnectedState) {
qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService called on busy socket";
errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
q->setSocketError(QBluetoothSocket::SocketError::OperationError);
return;
}
if (q->socketType() == QBluetoothServiceInfo::UnknownProtocol) {
qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService cannot "
"connect with 'UnknownProtocol' (type provided by given service)";
errorString = QBluetoothSocket::tr("Socket type not supported");
q->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
return;
}
if (!ensureNativeSocket(q->socketType())) {
errorString = QBluetoothSocket::tr("Socket type not supported");
q->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
return;
}
connectToServiceHelper(address, uuid, openMode);
}
void QBluetoothSocketPrivateAndroid::connectToService(
const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
{
Q_UNUSED(port);
Q_UNUSED(openMode);
Q_UNUSED(address);
Q_Q(QBluetoothSocket);
errorString = tr("Connecting to port is not supported");
q->setSocketError(QBluetoothSocket::SocketError::ServiceNotFoundError);
qCWarning(QT_BT_ANDROID) << "Connecting to port is not supported";
}
void QBluetoothSocketPrivateAndroid::socketConnectSuccess(const QJniObject &socket)
{
Q_Q(QBluetoothSocket);
QJniEnvironment env;
// test we didn't get a success from a previous connect
// which was cleaned up late
if (socket != socketObject)
return;
if (inputThread) {
inputThread->deleteLater();
inputThread = 0;
}
inputStream = socketObject.callMethod<QtJniTypes::InputStream>("getInputStream");
outputStream = socketObject.callMethod<QtJniTypes::OutputStream>("getOutputStream");
if (!inputStream.isValid() || !outputStream.isValid()) {
emit closeJavaSocket();
socketObject = inputStream = outputStream = remoteDevice = QJniObject();
errorString = QBluetoothSocket::tr("Obtaining streams for service failed");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
inputThread = new InputStreamThread(this);
QObject::connect(inputThread, SIGNAL(dataAvailable()),
q, SIGNAL(readyRead()), Qt::QueuedConnection);
QObject::connect(inputThread, SIGNAL(errorOccurred(int)), this, SLOT(inputThreadError(int)),
Qt::QueuedConnection);
if (!inputThread->run()) {
//close socket again
emit closeJavaSocket();
socketObject = inputStream = outputStream = remoteDevice = QJniObject();
delete inputThread;
inputThread = 0;
errorString = QBluetoothSocket::tr("Input stream thread cannot be started");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return;
}
// only unbuffered behavior supported at this stage
q->setOpenMode(QIODevice::ReadWrite|QIODevice::Unbuffered);
q->setSocketState(QBluetoothSocket::SocketState::ConnectedState);
}
void QBluetoothSocketPrivateAndroid::defaultSocketConnectFailed(
const QJniObject &socket, const QJniObject &targetUuid,
const QBluetoothUuid &qtTargetUuid)
{
Q_UNUSED(targetUuid);
Q_Q(QBluetoothSocket);
// test we didn't get a fail from a previous connect
// which was cleaned up late - should be same socket
if (socket != socketObject)
return;
if (!useReverseUuidWorkAroundConnect || !fallBackReversedConnect(qtTargetUuid)) {
errorString = QBluetoothSocket::tr("Connection to service failed");
socketObject = remoteDevice = QJniObject();
q->setSocketError(QBluetoothSocket::SocketError::ServiceNotFoundError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
qCWarning(QT_BT_ANDROID) << "Socket connect workaround failed";
}
}
void QBluetoothSocketPrivateAndroid::fallbackSocketConnectFailed(
const QJniObject &socket, const QJniObject &targetUuid)
{
Q_UNUSED(targetUuid);
Q_Q(QBluetoothSocket);
// test we didn't get a fail from a previous connect
// which was cleaned up late - should be same socket
if (socket != socketObject)
return;
qCWarning(QT_BT_ANDROID) << "Socket connect via workaround failed.";
errorString = QBluetoothSocket::tr("Connection to service failed");
socketObject = remoteDevice = QJniObject();
q->setSocketError(QBluetoothSocket::SocketError::ServiceNotFoundError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
}
void QBluetoothSocketPrivateAndroid::abort()
{
if (state == QBluetoothSocket::SocketState::UnconnectedState)
return;
if (socketObject.isValid()) {
QJniEnvironment env;
/*
* BluetoothSocket.close() triggers an abort of the input stream
* thread because inputStream.read() throws IOException
* In turn the thread stops and throws an error which sets
* new state, error and emits relevant signals.
* See QBluetoothSocketPrivateAndroid::inputThreadError() for details
*/
if (inputThread)
inputThread->prepareForClosure();
emit closeJavaSocket();
inputStream = outputStream = socketObject = remoteDevice = QJniObject();
if (inputThread) {
// inputThread exists hence we had a successful connect
// which means inputThread is responsible for setting Unconnected
//don't delete here as signals caused by Java Thread are still
//going to be emitted
//delete occurs in inputThreadError()
inputThread = 0;
} else {
// inputThread doesn't exist hence
// we abort in the middle of connect(). WorkerThread will do
// close() without further feedback. Therefore we have to set
// Unconnected (now) in advance
Q_Q(QBluetoothSocket);
q->setOpenMode(QIODevice::NotOpen);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
emit q->readChannelFinished();
}
}
}
QString QBluetoothSocketPrivateAndroid::localName() const
{
if (!ensureAndroidPermission(QBluetoothPermission::Access)) {
qCWarning(QT_BT_ANDROID) << "Bluetooth socket localName() failed due to"
"missing permissions";
} else if (adapter.isValid()) {
return adapter.callMethod<jstring>("getName").toString();
}
return QString();
}
QBluetoothAddress QBluetoothSocketPrivateAndroid::localAddress() const
{
QString result;
if (!ensureAndroidPermission(QBluetoothPermission::Access)) {
qCWarning(QT_BT_ANDROID) << "Bluetooth socket localAddress() failed due to"
"missing permissions";
} else if (adapter.isValid()) {
result = adapter.callMethod<jstring>("getAddress").toString();
}
return QBluetoothAddress(result);
}
quint16 QBluetoothSocketPrivateAndroid::localPort() const
{
// Impossible to get channel number with current Android API (Levels 5 to 19)
return 0;
}
QString QBluetoothSocketPrivateAndroid::peerName() const
{
if (!remoteDevice.isValid())
return QString();
return remoteDevice.callMethod<jstring>("getName").toString();
}
QBluetoothAddress QBluetoothSocketPrivateAndroid::peerAddress() const
{
if (!remoteDevice.isValid())
return QBluetoothAddress();
const QString address = remoteDevice.callMethod<jstring>("getAddress").toString();
return QBluetoothAddress(address);
}
quint16 QBluetoothSocketPrivateAndroid::peerPort() const
{
// Impossible to get channel number with current Android API (Levels 5 to 13)
return 0;
}
qint64 QBluetoothSocketPrivateAndroid::writeData(const char *data, qint64 maxSize)
{
//TODO implement buffered behavior (so far only unbuffered)
Q_Q(QBluetoothSocket);
if (state != QBluetoothSocket::SocketState::ConnectedState || !outputStream.isValid()) {
qCWarning(QT_BT_ANDROID) << "Socket::writeData: " << state << outputStream.isValid();
errorString = QBluetoothSocket::tr("Cannot write while not connected");
q->setSocketError(QBluetoothSocket::SocketError::OperationError);
return -1;
}
const qint32 javaSize = q26::saturate_cast<qint32>(maxSize);
QJniEnvironment env;
jbyteArray nativeData = env->NewByteArray(javaSize);
env->SetByteArrayRegion(nativeData, 0, javaSize, reinterpret_cast<const jbyte*>(data));
auto methodId = env.findMethod(outputStream.objectClass(),
"write",
"([BII)V");
if (methodId)
env->CallVoidMethod(outputStream.object(), methodId, nativeData, 0, javaSize);
env->DeleteLocalRef(nativeData);
if (!methodId || env.checkAndClearExceptions()) {
qCWarning(QT_BT_ANDROID) << "Error while writing";
errorString = QBluetoothSocket::tr("Error during write on socket.");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
return -1;
}
emit q->bytesWritten(javaSize);
return javaSize;
}
qint64 QBluetoothSocketPrivateAndroid::readData(char *data, qint64 maxSize)
{
Q_Q(QBluetoothSocket);
if (state != QBluetoothSocket::SocketState::ConnectedState || !inputThread) {
qCWarning(QT_BT_ANDROID) << "Socket::readData: " << state << inputThread ;
errorString = QBluetoothSocket::tr("Cannot read while not connected");
q->setSocketError(QBluetoothSocket::SocketError::OperationError);
return -1;
}
return inputThread->readData(data, maxSize);
}
void QBluetoothSocketPrivateAndroid::inputThreadError(int errorCode)
{
Q_Q(QBluetoothSocket);
if (errorCode != -1) { //magic error which is expected and can be ignored
errorString = QBluetoothSocket::tr("Network error during read");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
}
//finally we can delete the InputStreamThread
InputStreamThread *client = qobject_cast<InputStreamThread *>(sender());
if (client)
client->deleteLater();
if (socketObject.isValid()) {
//triggered when remote side closed the socket
//cleanup internal objects
//if it was call to local close()/abort() the objects are cleaned up already
emit closeJavaSocket();
inputStream = outputStream = remoteDevice = socketObject = QJniObject();
if (inputThread) {
// deleted already above (client->deleteLater())
inputThread = 0;
}
}
q->setOpenMode(QIODevice::NotOpen);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
emit q->readChannelFinished();
}
void QBluetoothSocketPrivateAndroid::close()
{
/* This function is called by QBluetoothSocket::close and softer version
QBluetoothSocket::disconnectFromService() which difference I do not quite fully understand.
Anyways we end up in Android "close" function call.
*/
abort();
}
bool QBluetoothSocketPrivateAndroid::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
{
Q_UNUSED(socketDescriptor);
Q_UNUSED(socketType);
Q_UNUSED(socketState);
Q_UNUSED(openMode);
qCWarning(QT_BT_ANDROID) << "No socket descriptor support on Android.";
return false;
}
bool QBluetoothSocketPrivateAndroid::setSocketDescriptor(const QJniObject &socket, QBluetoothServiceInfo::Protocol socketType_,
QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
if (q->state() != QBluetoothSocket::SocketState::UnconnectedState || !socket.isValid())
return false;
if (!ensureNativeSocket(socketType_))
return false;
socketObject = socket;
inputStream = socketObject.callMethod<QtJniTypes::InputStream>("getInputStream");
outputStream = socketObject.callMethod<QtJniTypes::OutputStream>("getOutputStream");
if (!inputStream.isValid() || !outputStream.isValid()) {
//close socket again
socketObject.callMethod<void>("close");
socketObject = inputStream = outputStream = remoteDevice = QJniObject();
errorString = QBluetoothSocket::tr("Obtaining streams for service failed");
q->setSocketError(QBluetoothSocket::SocketError::NetworkError);
q->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
return false;
}
remoteDevice = socketObject.callMethod<QtJniTypes::BluetoothDevice>("getRemoteDevice");
if (inputThread) {
inputThread->deleteLater();
inputThread = 0;
}
inputThread = new InputStreamThread(this);
QObject::connect(inputThread, SIGNAL(dataAvailable()),
q, SIGNAL(readyRead()), Qt::QueuedConnection);
QObject::connect(inputThread, SIGNAL(errorOccurred(int)), this, SLOT(inputThreadError(int)),
Qt::QueuedConnection);
inputThread->run();
// WorkerThread manages all sockets for us
// When we come through here the socket was already connected by
// server socket listener (see QBluetoothServer)
// Therefore we only use WorkerThread to potentially close it later on
WorkerThread *workerThread = new WorkerThread();
workerThread->setupWorker(this, socketObject, QJniObject(), !USE_FALLBACK);
workerThread->start();
q->setOpenMode(openMode | QIODevice::Unbuffered);
q->setSocketState(socketState);
return true;
}
qint64 QBluetoothSocketPrivateAndroid::bytesAvailable() const
{
//We cannot access buffer directly as it is part of different thread
if (inputThread)
return inputThread->bytesAvailable();
return 0;
}
qint64 QBluetoothSocketPrivateAndroid::bytesToWrite() const
{
return 0; // nothing because always unbuffered
}
/*
* This function is part of a workaround for QTBUG-61392
*
* Returns null uuid if the given \a serviceUuid is not a uuid
* derived from the Bluetooth base uuid.
*/
QBluetoothUuid QBluetoothSocketPrivateAndroid::reverseUuid(const QBluetoothUuid &serviceUuid)
{
if (serviceUuid.isNull())
return QBluetoothUuid();
bool isBaseUuid = false;
serviceUuid.toUInt32(&isBaseUuid);
if (isBaseUuid)
return serviceUuid;
const QUuid::Id128Bytes original = serviceUuid.toBytes();
QUuid::Id128Bytes reversed;
for (int i = 0; i < 16; i++)
reversed.data[15-i] = original.data[i];
return QBluetoothUuid{reversed};
}
bool QBluetoothSocketPrivateAndroid::canReadLine() const
{
// We cannot access buffer directly as it is part of different thread
if (inputThread)
return inputThread->canReadLine();
return false;
}
QT_END_NAMESPACE
#include <qbluetoothsocket_android.moc>