- Qt 5.5
- Qt Bluetooth
- C++ Classes
- QBluetoothSocket
- Qt 5.5.1 Reference Documentation

# QBluetoothSocket Class

The QBluetoothSocket class enables connection to a Bluetooth device running a bluetooth server. More...

Header: | #include <QBluetoothSocket>
qmake: | QT += bluetooth
Since: | Qt 5.2
Inherits: |

- List of all members, including inherited members

## Public Types

enum | SocketError { UnknownSocketError, NoSocketError, HostNotFoundError, ServiceNotFoundError, ..., OperationError }
enum | SocketState { UnconnectedState, ServiceLookupState, ConnectingState, ConnectedState, ..., ListeningState }

## Public Functions

| QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject * parent = 0)
| QBluetoothSocket(QObject * parent = 0)
virtual | ~QBluetoothSocket()
void | abort()
virtual qint64 | bytesAvailable() const
virtual qint64 | bytesToWrite() const
virtual bool | canReadLine() const
virtual void | close()
void | connectToService(const QBluetoothServiceInfo & service, OpenMode openMode = ReadWrite)
void | connectToService(const QBluetoothAddress & address, const QBluetoothUuid & uuid, OpenMode openMode = ReadWrite)
void | connectToService(const QBluetoothAddress & address, quint16 port, OpenMode openMode = ReadWrite)
void | disconnectFromService()
SocketError | error() const
QString | errorString() const
bool | isSequential() const
QBluetoothAddress | localAddress() const
QString | localName() const
quint16 | localPort() const
QBluetoothAddress | peerAddress() const
QString | peerName() const
quint16 | peerPort() const
bool | setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType, SocketState socketState = ConnectedState, OpenMode openMode = ReadWrite)
int | socketDescriptor() const
QBluetoothServiceInfo::Protocol | socketType() const
SocketState | state() const

## Signals

void | connected()
void | disconnected()
void | error(QBluetoothSocket::SocketError error)
void | stateChanged(QBluetoothSocket::SocketState state)

## Protected Functions

void | doDeviceDiscovery(const QBluetoothServiceInfo & service, OpenMode openMode)
virtual qint64 | readData(char * data, qint64 maxSize)
void | setSocketError(SocketError error_)
void | setSocketState(SocketState state)
virtual qint64 | writeData(const char * data, qint64 maxSize)

## Detailed Description

The QBluetoothSocket class enables connection to a Bluetooth device running a bluetooth server.

QBluetoothSocket supports two socket types, L2CAP and RFCOMM.

L2CAP is a low level datagram-oriented Bluetooth socket. Android and BlackBerry do not support L2CAP for socket connections.

RFCOMM is a reliable, stream-oriented socket. RFCOMM sockets emulate an RS-232 serial port.

To create a connection to a Bluetooth service, create a socket of the appropriate type and call connectToService() passing the Bluetooth address and port number. QBluetoothSocket will emit the connected() signal when the connection is established.

If the Protocol is not supported on a platform, calling connectToService() will emit a UnsupportedProtocolError error.

## Member Type Documentation

### enum QBluetoothSocket::SocketError

This enum describes Bluetooth socket error types.

Constant | Value | Description
--- | --- | ---
`QBluetoothSocket::UnknownSocketError` | `QAbstractSocket::UnknownSocketError` | An unknown error has occurred.
`QBluetoothSocket::NoSocketError` | `-2` | No error. Used for testing.
`QBluetoothSocket::HostNotFoundError` | `QAbstractSocket::HostNotFoundError` | Could not find the remote host.
`QBluetoothSocket::ServiceNotFoundError` | `QAbstractSocket::SocketAddressNotAvailableError` | Could not find the service UUID on remote host.
`QBluetoothSocket::NetworkError` | `QAbstractSocket::NetworkError` | Attempt to read or write from socket returned an error
`QBluetoothSocket::UnsupportedProtocolError` | `8` | The Protocol is not supported on this platform.
`QBluetoothSocket::OperationError` | `QAbstractSocket::OperationError` | An operation was attempted while the socket was in a state that did not permit it.

### enum QBluetoothSocket::SocketState

This enum describes the state of the Bluetooth socket.

Constant | Value | Description
--- | --- | ---
`QBluetoothSocket::UnconnectedState` | `QAbstractSocket::UnconnectedState` | Socket is not connected.
`QBluetoothSocket::ServiceLookupState` | `QAbstractSocket::HostLookupState` | Socket is querying connection parameters.
`QBluetoothSocket::ConnectingState` | `QAbstractSocket::ConnectingState` | Socket is attempting to connect to a device.
`QBluetoothSocket::ConnectedState` | `QAbstractSocket::ConnectedState` | Socket is connected to a device.
`QBluetoothSocket::BoundState` | `QAbstractSocket::BoundState` | Socket is bound to a local address and port.
`QBluetoothSocket::ClosingState` | `QAbstractSocket::ClosingState` | Socket is connected and will be closed once all pending data is written to the socket.
`QBluetoothSocket::ListeningState` | `QAbstractSocket::ListeningState` | Socket is listening for incoming connections.

## Member Function Documentation

### QBluetoothSocket::QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject * parent = 0)

Constructs a Bluetooth socket of socketType type, with parent.

### QBluetoothSocket::QBluetoothSocket(QObject * parent = 0)

Constructs a Bluetooth socket with parent.

### `[virtual]` QBluetoothSocket::~QBluetoothSocket()

Destroys the Bluetooth socket.

### void QBluetoothSocket::abort()

Aborts the current connection and resets the socket. Unlike disconnectFromService(), this function immediately closes the socket, discarding any pending data in the write buffer.

Note: On Android, aborting the socket requires asynchronous interaction with Android threads. Therefore the associated disconnected() and stateChanged() signals are delayed until the threads have finished the closure.

See also disconnectFromService() and close().

### `[virtual]` qint64 QBluetoothSocket::bytesAvailable() const

Returns the number of incoming bytes that are waiting to be read.

See also bytesToWrite() and read().

### `[virtual]` qint64 QBluetoothSocket::bytesToWrite() const

Returns the number of bytes that are waiting to be written. The bytes are written when control goes back to the event loop.

### `[virtual]` bool QBluetoothSocket::canReadLine() const

Returns true if you can read at least one line from the device

### `[virtual]` void QBluetoothSocket::close()

Disconnects the socket's connection with the device.

Note: On Android, closing the socket requires asynchronous interaction with Android threads. Therefore the associated disconnected() and stateChanged() signals are delayed until the threads have finished the closure.

### void QBluetoothSocket::connectToService(const QBluetoothServiceInfo & service, OpenMode openMode = ReadWrite)

Attempts to connect to the service described by service.

The socket is opened in the given openMode. The socketType() may change depending on the protocol required by service.

The socket first enters ConnectingState and attempts to connect to the device providing 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.

See also state() and disconnectFromService().

### void QBluetoothSocket::connectToService(const QBluetoothAddress & address, const QBluetoothUuid & uuid, OpenMode openMode = ReadWrite)

Attempts to make a connection to the service identified by uuid on the device with address address.

The socket is opened in the given openMode.

For BlueZ, the socket first enters the ServiceLookupState and queries the connection parameters for uuid. If the service parameters are successfully retrieved the socket enters ConnectingState, and attempts to connect to 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 ServiceLookupState and socketType() is always set to 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.

See also state() and disconnectFromService().

### void QBluetoothSocket::connectToService(const QBluetoothAddress & address, quint16 port, OpenMode openMode = ReadWrite)

Attempts to make a connection with address on the given port.

The socket is opened in the given openMode.

The socket first enters ConnectingState, and attempts to connect to address. 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.

On BlackBerry and Android, a connection to a service can not be established using a port. Calling this function will emit a ServiceNotFoundError

Note that most platforms require a pairing prior to connecting to the remote device. Otherwise the connection process may fail.

See also state() and disconnectFromService().

### `[signal]` void QBluetoothSocket::connected()

This signal is emitted when a connection is established.

See also QBluetoothSocket::ConnectedState and stateChanged().

### void QBluetoothSocket::disconnectFromService()

Attempts to close the socket. If there is pending data waiting to be written QBluetoothSocket will enter ClosingState and wait until all data has been written. Eventually, it will enter UnconnectedState and emit the disconnected() signal.

See also connectToService().

### `[signal]` void QBluetoothSocket::disconnected()

This signal is emitted when the socket is disconnected.

See also QBluetoothSocket::UnconnectedState and stateChanged().

### `[protected]` void QBluetoothSocket::doDeviceDiscovery(const QBluetoothServiceInfo & service, OpenMode openMode)

Start device discovery for service and open the socket with openMode. If the socket is created with a service uuid device address, use service discovery to find the port number to connect to.

### SocketError QBluetoothSocket::error() const

Returns the last error.

### `[signal]` void QBluetoothSocket::error(QBluetoothSocket::SocketError error)

This signal is emitted when an error occurs.

See also error().

### QString QBluetoothSocket::errorString() const

Returns a user displayable text string for the error.

### bool QBluetoothSocket::isSequential() const

### QBluetoothAddress QBluetoothSocket::localAddress() const

Returns the address of the local device.

Although some platforms may differ the socket must generally be connected to guarantee the return of a valid address. In particular, this is true when dealing with platforms that support multiple local Bluetooth adapters.

### QString QBluetoothSocket::localName() const

Returns the name of the local device.

Although some platforms may differ the socket must generally be connected to guarantee the return of a valid name. In particular, this is true when dealing with platforms that support multiple local Bluetooth adapters.

### quint16 QBluetoothSocket::localPort() const

Returns the port number of the local socket if available, otherwise returns 0. Although some platforms may differ the socket must generally be connected to guarantee the return of a valid port number.

On BlackBerry, Android and OS X, this feature is not supported and returns 0.

### QBluetoothAddress QBluetoothSocket::peerAddress() const

Returns the address of the peer device.

### QString QBluetoothSocket::peerName() const

Returns the name of the peer device.

### quint16 QBluetoothSocket::peerPort() const

Return the port number of the peer socket if available, otherwise returns 0. On BlackBerry and Android, this feature is not supported.

### `[virtual protected]` qint64 QBluetoothSocket::readData(char * data, qint64 maxSize)

### bool QBluetoothSocket::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType, SocketState socketState = ConnectedState, OpenMode openMode = ReadWrite)

Set the socket to use socketDescriptor with a type of socketType, which is in state, socketState, and mode, openMode.

Returns true on success

See also socketDescriptor().

### `[protected]` void QBluetoothSocket::setSocketError(SocketError error_)

Sets the type of error that last occurred to error_.

### `[protected]` void QBluetoothSocket::setSocketState(SocketState state)

Sets the socket state to state.

### int QBluetoothSocket::socketDescriptor() const

Returns the platform-specific socket descriptor, if available. This function returns -1 if the descriptor is not available or an error has occurred.

See also setSocketDescriptor().

### QBluetoothServiceInfo::Protocol QBluetoothSocket::socketType() const

Returns the socket type. The socket automatically adjusts to the protocol offered by the remote service.

Blackberry and Android only support RFCOMM based sockets.

### SocketState QBluetoothSocket::state() const

Returns the current state of the socket.

### `[signal]` void QBluetoothSocket::stateChanged(QBluetoothSocket::SocketState state)

This signal is emitted when the socket state changes to state.

See also connected(), disconnected(), state(), and QBluetoothSocket::SocketState.

### `[virtual protected]` qint64 QBluetoothSocket::writeData(const char * data, qint64 maxSize)