From 17d9b0d5bf5630a403345221309adc615b59db77 Mon Sep 17 00:00:00 2001 From: Alex Blasche Date: Fri, 5 Sep 2014 10:59:34 +0200 Subject: Rename defines which indicate ATT header sizes Adding HEADER to the name makes it more obvious which part of the message is meant. Change-Id: I207db40134db1ce558ccf89c3fd8b53fa68891f6 Reviewed-by: Fabian Bumberger --- src/bluetooth/qlowenergycontroller_bluez.cpp | 86 ++++++++++++++-------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/src/bluetooth/qlowenergycontroller_bluez.cpp b/src/bluetooth/qlowenergycontroller_bluez.cpp index 6c74fdc9..da26a35e 100644 --- a/src/bluetooth/qlowenergycontroller_bluez.cpp +++ b/src/bluetooth/qlowenergycontroller_bluez.cpp @@ -76,15 +76,15 @@ #define ATT_OP_WRITE_COMMAND 0x52 //write characteristic without response //GATT command sizes in bytes -#define FIND_INFO_REQUEST_SIZE 5 -#define GRP_TYPE_REQ_SIZE 7 -#define READ_BY_TYPE_REQ_SIZE 7 -#define READ_REQUEST_SIZE 3 -#define READ_BLOB_REQUEST_SIZE 5 -#define WRITE_REQUEST_SIZE 3 // same size for WRITE_COMMAND -#define PREPARE_WRITE_SIZE 5 -#define EXECUTE_WRITE_SIZE 2 -#define MTU_EXCHANGE_SIZE 3 +#define FIND_INFO_REQUEST_HEADER_SIZE 5 +#define GRP_TYPE_REQ_HEADER_SIZE 7 +#define READ_BY_TYPE_REQ_HEADER_SIZE 7 +#define READ_REQUEST_HEADER_SIZE 3 +#define READ_BLOB_REQUEST_HEADER_SIZE 5 +#define WRITE_REQUEST_HEADER_SIZE 3 // same size for WRITE_COMMAND header +#define PREPARE_WRITE_HEADER_SIZE 5 +#define EXECUTE_WRITE_HEADER_SIZE 2 +#define MTU_EXCHANGE_HEADER_SIZE 3 // GATT error codes #define ATT_ERROR_INVALID_HANDLE 0x01 @@ -873,15 +873,15 @@ void QLowEnergyControllerPrivate::sendReadByGroupRequest( QLowEnergyHandle start, QLowEnergyHandle end, quint16 type) { //call for primary and secondary services - quint8 packet[GRP_TYPE_REQ_SIZE]; + quint8 packet[GRP_TYPE_REQ_HEADER_SIZE]; packet[0] = ATT_OP_READ_BY_GROUP_REQUEST; bt_put_unaligned(htobs(start), (quint16 *) &packet[1]); bt_put_unaligned(htobs(end), (quint16 *) &packet[3]); bt_put_unaligned(htobs(type), (quint16 *) &packet[5]); - QByteArray data(GRP_TYPE_REQ_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, GRP_TYPE_REQ_SIZE); + QByteArray data(GRP_TYPE_REQ_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, GRP_TYPE_REQ_HEADER_SIZE); qCDebug(QT_BT_BLUEZ) << "Sending read_by_group_type request, startHandle:" << hex << start << "endHandle:" << end << type; @@ -911,15 +911,15 @@ void QLowEnergyControllerPrivate::sendReadByTypeRequest( QSharedPointer serviceData, QLowEnergyHandle nextHandle, quint16 attributeType) { - quint8 packet[READ_BY_TYPE_REQ_SIZE]; + quint8 packet[READ_BY_TYPE_REQ_HEADER_SIZE]; packet[0] = ATT_OP_READ_BY_TYPE_REQUEST; bt_put_unaligned(htobs(nextHandle), (quint16 *) &packet[1]); bt_put_unaligned(htobs(serviceData->endHandle), (quint16 *) &packet[3]); bt_put_unaligned(htobs(attributeType), (quint16 *) &packet[5]); - QByteArray data(READ_BY_TYPE_REQ_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, READ_BY_TYPE_REQ_SIZE); + QByteArray data(READ_BY_TYPE_REQ_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, READ_BY_TYPE_REQ_HEADER_SIZE); qCDebug(QT_BT_BLUEZ) << "Sending read_by_type request, startHandle:" << hex << nextHandle << "endHandle:" << serviceData->endHandle << "type:" << attributeType << "packet:" << data.toHex(); @@ -945,7 +945,7 @@ void QLowEnergyControllerPrivate::sendReadByTypeRequest( void QLowEnergyControllerPrivate::readServiceValues( const QBluetoothUuid &serviceUuid, bool readCharacteristics) { - quint8 packet[READ_REQUEST_SIZE]; + quint8 packet[READ_REQUEST_HEADER_SIZE]; if (QT_BT_BLUEZ().isDebugEnabled()) { if (readCharacteristics) qCDebug(QT_BT_BLUEZ) << "Reading characteristic values for" @@ -1009,8 +1009,8 @@ void QLowEnergyControllerPrivate::readServiceValues( packet[0] = ATT_OP_READ_REQUEST; bt_put_unaligned(htobs(pair.first), (quint16 *) &packet[1]); - QByteArray data(READ_REQUEST_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, READ_REQUEST_SIZE); + QByteArray data(READ_REQUEST_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, READ_REQUEST_HEADER_SIZE); Request request; request.payload = data; @@ -1039,7 +1039,7 @@ void QLowEnergyControllerPrivate::readServiceValuesByOffset( { const QLowEnergyHandle charHandle = (handleData & 0xffff); const QLowEnergyHandle descriptorHandle = ((handleData >> 16) & 0xffff); - quint8 packet[READ_REQUEST_SIZE]; + quint8 packet[READ_REQUEST_HEADER_SIZE]; packet[0] = ATT_OP_READ_BLOB_REQUEST; @@ -1065,8 +1065,8 @@ void QLowEnergyControllerPrivate::readServiceValuesByOffset( bt_put_unaligned(htobs(handleToRead), (quint16 *) &packet[1]); bt_put_unaligned(htobs(offset), (quint16 *) &packet[3]); - QByteArray data(READ_BLOB_REQUEST_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, READ_BLOB_REQUEST_SIZE); + QByteArray data(READ_BLOB_REQUEST_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, READ_BLOB_REQUEST_HEADER_SIZE); Request request; request.payload = data; @@ -1123,12 +1123,12 @@ void QLowEnergyControllerPrivate::exchangeMTU() { qCDebug(QT_BT_BLUEZ) << "Exchanging MTU"; - quint8 packet[MTU_EXCHANGE_SIZE]; + quint8 packet[MTU_EXCHANGE_HEADER_SIZE]; packet[0] = ATT_OP_EXCHANGE_MTU_REQUEST; bt_put_unaligned(htobs(ATT_MAX_LE_MTU), (quint16 *) &packet[1]); - QByteArray data(MTU_EXCHANGE_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, MTU_EXCHANGE_SIZE); + QByteArray data(MTU_EXCHANGE_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, MTU_EXCHANGE_HEADER_SIZE); Request request; request.payload = data; @@ -1149,7 +1149,7 @@ void QLowEnergyControllerPrivate::discoverNextDescriptor( qCDebug(QT_BT_BLUEZ) << "Sending find_info request" << hex << pendingCharHandles << startingHandle; - quint8 packet[FIND_INFO_REQUEST_SIZE]; + quint8 packet[FIND_INFO_REQUEST_HEADER_SIZE]; packet[0] = ATT_OP_FIND_INFORMATION_REQUEST; const QLowEnergyHandle charStartHandle = startingHandle; @@ -1162,8 +1162,8 @@ void QLowEnergyControllerPrivate::discoverNextDescriptor( bt_put_unaligned(htobs(charStartHandle), (quint16 *) &packet[1]); bt_put_unaligned(htobs(charEndHandle), (quint16 *) &packet[3]); - QByteArray data(FIND_INFO_REQUEST_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, FIND_INFO_REQUEST_SIZE); + QByteArray data(FIND_INFO_REQUEST_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, FIND_INFO_REQUEST_HEADER_SIZE); Request request; request.payload = data; @@ -1183,7 +1183,7 @@ void QLowEnergyControllerPrivate::sendNextPrepareWriteRequest( Q_ASSERT(service); const QLowEnergyHandle valueHandle = service->characteristicList[charHandle].valueHandle; - quint8 packet[PREPARE_WRITE_SIZE]; + quint8 packet[PREPARE_WRITE_HEADER_SIZE]; packet[0] = ATT_OP_PREPARE_WRITE_REQUEST; bt_put_unaligned(htobs(valueHandle), (quint16 *) &packet[1]); // attribute handle bt_put_unaligned(htobs(offset), (quint16 *) &packet[3]); // offset into newValue @@ -1192,16 +1192,16 @@ void QLowEnergyControllerPrivate::sendNextPrepareWriteRequest( << hex << charHandle; - const int maxAvailablePayload = mtuSize - PREPARE_WRITE_SIZE; + const int maxAvailablePayload = mtuSize - PREPARE_WRITE_HEADER_SIZE; const int requiredPayload = qMin(newValue.size() - offset, maxAvailablePayload); - const int dataSize = PREPARE_WRITE_SIZE + requiredPayload; + const int dataSize = PREPARE_WRITE_HEADER_SIZE + requiredPayload; Q_ASSERT((offset + requiredPayload) <= newValue.size()); Q_ASSERT(dataSize <= mtuSize); QByteArray data(dataSize, Qt::Uninitialized); - memcpy(data.data(), packet, PREPARE_WRITE_SIZE); - memcpy(&(data.data()[PREPARE_WRITE_SIZE]), &(newValue.constData()[offset]), + memcpy(data.data(), packet, PREPARE_WRITE_HEADER_SIZE); + memcpy(&(data.data()[PREPARE_WRITE_HEADER_SIZE]), &(newValue.constData()[offset]), requiredPayload); Request request; @@ -1225,15 +1225,15 @@ void QLowEnergyControllerPrivate::sendExecuteWriteRequest( const QLowEnergyHandle charHandle, const QByteArray &newValue, bool isCancelation) { - quint8 packet[EXECUTE_WRITE_SIZE]; + quint8 packet[EXECUTE_WRITE_HEADER_SIZE]; packet[0] = ATT_OP_EXECUTE_WRITE_REQUEST; if (isCancelation) packet[1] = 0x00; // cancel pending write prepare requests else packet[1] = 0x01; // execute pending write prepare requests - QByteArray data(EXECUTE_WRITE_SIZE, Qt::Uninitialized); - memcpy(data.data(), packet, EXECUTE_WRITE_SIZE); + QByteArray data(EXECUTE_WRITE_HEADER_SIZE, Qt::Uninitialized); + memcpy(data.data(), packet, EXECUTE_WRITE_HEADER_SIZE); qCDebug(QT_BT_BLUEZ) << "Sending Execute Write Request for long characteristic value" << hex << charHandle; @@ -1265,11 +1265,11 @@ void QLowEnergyControllerPrivate::writeCharacteristic( return; const QLowEnergyHandle valueHandle = service->characteristicList[charHandle].valueHandle; - const int size = WRITE_REQUEST_SIZE + newValue.size(); + const int size = WRITE_REQUEST_HEADER_SIZE + newValue.size(); - quint8 packet[WRITE_REQUEST_SIZE]; + quint8 packet[WRITE_REQUEST_HEADER_SIZE]; if (writeWithResponse) { - if (newValue.size() > (mtuSize - WRITE_REQUEST_SIZE)) { + if (newValue.size() > (mtuSize - WRITE_REQUEST_HEADER_SIZE)) { sendNextPrepareWriteRequest(charHandle, newValue, 0); sendNextPendingRequest(); return; @@ -1285,8 +1285,8 @@ void QLowEnergyControllerPrivate::writeCharacteristic( bt_put_unaligned(htobs(valueHandle), (quint16 *) &packet[1]); QByteArray data(size, Qt::Uninitialized); - memcpy(data.data(), packet, WRITE_REQUEST_SIZE); - memcpy(&(data.data()[WRITE_REQUEST_SIZE]), newValue.constData(), newValue.size()); + memcpy(data.data(), packet, WRITE_REQUEST_HEADER_SIZE); + memcpy(&(data.data()[WRITE_REQUEST_HEADER_SIZE]), newValue.constData(), newValue.size()); qCDebug(QT_BT_BLUEZ) << "Writing characteristic" << hex << charHandle << "(size:" << size << "with response:" << writeWithResponse << ")"; @@ -1321,13 +1321,13 @@ void QLowEnergyControllerPrivate::writeDescriptor( // sizeof(command) + sizeof(handle) + sizeof(newValue) const int size = 1 + 2 + newValue.size(); - quint8 packet[WRITE_REQUEST_SIZE]; + quint8 packet[WRITE_REQUEST_HEADER_SIZE]; packet[0] = ATT_OP_WRITE_REQUEST; bt_put_unaligned(htobs(descriptorHandle), (quint16 *) &packet[1]); QByteArray data(size, Qt::Uninitialized); - memcpy(data.data(), packet, WRITE_REQUEST_SIZE); - memcpy(&(data.data()[WRITE_REQUEST_SIZE]), newValue.constData(), newValue.size()); + memcpy(data.data(), packet, WRITE_REQUEST_HEADER_SIZE); + memcpy(&(data.data()[WRITE_REQUEST_HEADER_SIZE]), newValue.constData(), newValue.size()); qCDebug(QT_BT_BLUEZ) << "Writing descriptor" << hex << descriptorHandle << "(size:" << size << ")"; -- cgit v1.2.3