diff --git a/config.pri b/config.pri
index fc4787f..93ad169 100644
--- a/config.pri
+++ b/config.pri
@@ -1,7 +1,19 @@
 QT += gui serialport sql
 
-QMAKE_CXXFLAGS += -Werror -std=c++11 -z defs
-QMAKE_LFLAGS += -std=c++11
+greaterThan(QT_MAJOR_VERSION, 5) {
+    message("Building using Qt6 support")
+    CONFIG *= c++17
+    QMAKE_LFLAGS *= -std=c++17
+    QMAKE_CXXFLAGS *= -std=c++17
+} else {
+    message("Building using Qt5 support")
+    CONFIG *= c++11
+    QMAKE_LFLAGS *= -std=c++11
+    QMAKE_CXXFLAGS *= -std=c++11
+    DEFINES += QT_DISABLE_DEPRECATED_UP_TO=0x050F00
+}
+
+QMAKE_CXXFLAGS += -Werror -z defs
 
 sourceDir = $$PWD
 buildDir = $$shadowed($$PWD)
diff --git a/libnymea-zigbee/backends/deconz/interface/zigbeeinterfacedeconz.cpp b/libnymea-zigbee/backends/deconz/interface/zigbeeinterfacedeconz.cpp
index fb19e3b..31dda83 100644
--- a/libnymea-zigbee/backends/deconz/interface/zigbeeinterfacedeconz.cpp
+++ b/libnymea-zigbee/backends/deconz/interface/zigbeeinterfacedeconz.cpp
@@ -262,7 +262,11 @@ bool ZigbeeInterfaceDeconz::enable(const QString &serialPort, qint32 baudrate)
     m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
 
     connect(m_serialPort, &QSerialPort::readyRead, this, &ZigbeeInterfaceDeconz::onReadyRead);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
+    connect(m_serialPort, &QSerialPort::errorOccurred, this, &ZigbeeInterfaceDeconz::onError, Qt::QueuedConnection);
+#else
     connect(m_serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(onError(QSerialPort::SerialPortError)), Qt::QueuedConnection);
+#endif
 
     if (!m_serialPort->open(QSerialPort::ReadWrite)) {
         qCWarning(dcZigbeeInterface()) << "Could not open serial port" << serialPort << baudrate << m_serialPort->errorString();
diff --git a/libnymea-zigbee/backends/nxp/interface/zigbeeinterfacenxp.cpp b/libnymea-zigbee/backends/nxp/interface/zigbeeinterfacenxp.cpp
index f76232b..d4de8b8 100644
--- a/libnymea-zigbee/backends/nxp/interface/zigbeeinterfacenxp.cpp
+++ b/libnymea-zigbee/backends/nxp/interface/zigbeeinterfacenxp.cpp
@@ -259,7 +259,11 @@ bool ZigbeeInterfaceNxp::enable(const QString &serialPort, qint32 baudrate)
     m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
 
     connect(m_serialPort, &QSerialPort::readyRead, this, &ZigbeeInterfaceNxp::onReadyRead);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
+    connect(m_serialPort, &QSerialPort::errorOccurred, this, &ZigbeeInterfaceNxp::onError, Qt::QueuedConnection);
+#else
     connect(m_serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(onError(QSerialPort::SerialPortError)), Qt::QueuedConnection);
+#endif
 
     if (!m_serialPort->open(QSerialPort::ReadWrite)) {
         qCWarning(dcZigbeeInterface()) << "Could not open serial port" << serialPort << baudrate << m_serialPort->errorString();
diff --git a/libnymea-zigbee/backends/nxp/zigbeenetworknxp.cpp b/libnymea-zigbee/backends/nxp/zigbeenetworknxp.cpp
index 95e460d..f210b6a 100644
--- a/libnymea-zigbee/backends/nxp/zigbeenetworknxp.cpp
+++ b/libnymea-zigbee/backends/nxp/zigbeenetworknxp.cpp
@@ -89,7 +89,7 @@ ZigbeeNetworkReply *ZigbeeNetworkNxp::sendRequest(const ZigbeeNetworkRequest &re
             m_bufferedReplies.remove(requestId);
             return;
         }
-        //qCWarning(dcZigbeeNetwork()) << "#### Removed network reply" << reply << "ID:" << requestId << "Current reply count" << m_pendingReplies.count();
+        //qCWarning(dcZigbeeNetwork()) << "#### Removed network reply" << reply << "ID:" << requestId << "Current reply count" << m_pendingReplies.size();
     });
 
     // Finish the reply right away if the network is offline
diff --git a/libnymea-zigbee/backends/ti/interface/zigbeeinterfaceti.cpp b/libnymea-zigbee/backends/ti/interface/zigbeeinterfaceti.cpp
index 78453e5..298c45a 100644
--- a/libnymea-zigbee/backends/ti/interface/zigbeeinterfaceti.cpp
+++ b/libnymea-zigbee/backends/ti/interface/zigbeeinterfaceti.cpp
@@ -221,8 +221,12 @@ bool ZigbeeInterfaceTi::enable(const QString &serialPort, qint32 baudrate)
     m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
 
     connect(m_serialPort, &QSerialPort::readyRead, this, &ZigbeeInterfaceTi::onReadyRead);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
+    connect(m_serialPort, &QSerialPort::errorOccurred, this, &ZigbeeInterfaceTi::onError);
+#else
     typedef void (QSerialPort::* errorSignal)(QSerialPort::SerialPortError);
     connect(m_serialPort, static_cast<errorSignal>(&QSerialPort::error), this, &ZigbeeInterfaceTi::onError);
+#endif
 
     if (!m_serialPort->open(QSerialPort::ReadWrite)) {
         qCWarning(dcZigbeeInterface()) << "Could not open serial port" << serialPort << baudrate << m_serialPort->errorString();
diff --git a/libnymea-zigbee/libnymea-zigbee.pro b/libnymea-zigbee/libnymea-zigbee.pro
index 0ee1210..e79436c 100644
--- a/libnymea-zigbee/libnymea-zigbee.pro
+++ b/libnymea-zigbee/libnymea-zigbee.pro
@@ -11,8 +11,13 @@ packagesExist(libudev) {
     message(Build without libudev support)
     DEFINES += DISABLE_UDEV
 }
-
-PKGCONFIG += qca2-qt5
+greaterThan(QT_MAJOR_VERSION, 5) {
+    # Note: available since mantic
+    # PKGCONFIG += qca2-qt6
+    DEFINES += DISABLE_TI
+} else {
+    PKGCONFIG += qca2-qt5
+}
 
 SOURCES += \
     backends/deconz/interface/zigbeeinterfacedeconz.cpp \
@@ -24,10 +29,6 @@ SOURCES += \
     backends/nxp/interface/zigbeeinterfacenxpreply.cpp \
     backends/nxp/zigbeebridgecontrollernxp.cpp \
     backends/nxp/zigbeenetworknxp.cpp \
-    backends/ti/interface/zigbeeinterfaceti.cpp \
-    backends/ti/interface/zigbeeinterfacetireply.cpp \
-    backends/ti/zigbeebridgecontrollerti.cpp \
-    backends/ti/zigbeenetworkti.cpp \
     zcl/closures/zigbeeclusterdoorlock.cpp \
     zcl/closures/zigbeeclusterwindowcovering.cpp \
     zcl/general/zigbeeclusteranaloginput.cpp \
@@ -90,6 +91,21 @@ SOURCES += \
     zigbeenode.cpp \
     zigbeeaddress.cpp
 
+!contains(DEFINES, DISABLE_TI) {
+    SOURCES += \
+        backends/ti/interface/zigbeeinterfaceti.cpp \
+        backends/ti/interface/zigbeeinterfacetireply.cpp \
+        backends/ti/zigbeebridgecontrollerti.cpp \
+        backends/ti/zigbeenetworkti.cpp \
+
+    HEADERS += \
+        backends/ti/interface/ti.h \
+        backends/ti/interface/zigbeeinterfaceti.h \
+        backends/ti/interface/zigbeeinterfacetireply.h \
+        backends/ti/zigbeebridgecontrollerti.h \
+        backends/ti/zigbeenetworkti.h \
+}
+
 HEADERS += \
     backends/deconz/interface/deconz.h \
     backends/deconz/interface/zigbeeinterfacedeconz.h \
@@ -102,11 +118,6 @@ HEADERS += \
     backends/nxp/interface/zigbeeinterfacenxpreply.h \
     backends/nxp/zigbeebridgecontrollernxp.h \
     backends/nxp/zigbeenetworknxp.h \
-    backends/ti/interface/ti.h \
-    backends/ti/interface/zigbeeinterfaceti.h \
-    backends/ti/interface/zigbeeinterfacetireply.h \
-    backends/ti/zigbeebridgecontrollerti.h \
-    backends/ti/zigbeenetworkti.h \
     zcl/closures/zigbeeclusterdoorlock.h \
     zcl/closures/zigbeeclusterwindowcovering.h \
     zcl/general/zigbeeclusteranaloginput.h \
diff --git a/libnymea-zigbee/zcl/general/zigbeeclustergroups.cpp b/libnymea-zigbee/zcl/general/zigbeeclustergroups.cpp
index 66569bb..3eb272f 100644
--- a/libnymea-zigbee/zcl/general/zigbeeclustergroups.cpp
+++ b/libnymea-zigbee/zcl/general/zigbeeclustergroups.cpp
@@ -39,7 +39,11 @@ ZigbeeClusterGroups::ZigbeeClusterGroups(ZigbeeNetwork *network, ZigbeeNode *nod
 ZigbeeClusterReply *ZigbeeClusterGroups::addGroup(quint16 groupId, const QString &groupName)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << groupId << static_cast<quint8>(Zigbee::CharString);
     for (int i = 0; i < groupName.length(); i++) {
@@ -51,7 +55,11 @@ ZigbeeClusterReply *ZigbeeClusterGroups::addGroup(quint16 groupId, const QString
 ZigbeeClusterReply *ZigbeeClusterGroups::viewGroup(quint16 groupId)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << groupId;
     return executeClusterCommand(ZigbeeClusterGroups::CommandViewGroup, payload);
@@ -60,7 +68,11 @@ ZigbeeClusterReply *ZigbeeClusterGroups::viewGroup(quint16 groupId)
 ZigbeeClusterReply *ZigbeeClusterGroups::getGroupMembership(quint8 groupCount, const QList<quint16> &groupList)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << groupCount;
     for (int i = 0; i < groupList.length(); i++) {
@@ -72,7 +84,11 @@ ZigbeeClusterReply *ZigbeeClusterGroups::getGroupMembership(quint8 groupCount, c
 ZigbeeClusterReply *ZigbeeClusterGroups::removeGroup(quint16 groupId)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << groupId;
     return executeClusterCommand(ZigbeeClusterGroups::CommandRemoveGroup, payload);
@@ -86,7 +102,11 @@ ZigbeeClusterReply *ZigbeeClusterGroups::removeAllGroups()
 ZigbeeClusterReply *ZigbeeClusterGroups::addGroupIfIdentifying(quint16 groupId, const QString &groupName)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << groupId << static_cast<quint8>(Zigbee::CharString);
     for (int i = 0; i < groupName.length(); i++) {
diff --git a/libnymea-zigbee/zcl/general/zigbeeclusterscenes.cpp b/libnymea-zigbee/zcl/general/zigbeeclusterscenes.cpp
index 2df038e..33bc064 100644
--- a/libnymea-zigbee/zcl/general/zigbeeclusterscenes.cpp
+++ b/libnymea-zigbee/zcl/general/zigbeeclusterscenes.cpp
@@ -44,7 +44,11 @@ void ZigbeeClusterScenes::processDataIndication(ZigbeeClusterLibrary::Frame fram
         // Read the payload which is
         Command command = static_cast<Command>(frame.header.command);
         QByteArray payload = frame.payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        QDataStream payloadStream(&payload, QDataStream::ReadOnly);
+#else
         QDataStream payloadStream(&payload, QIODevice::ReadOnly);
+#endif
         payloadStream.setByteOrder(QDataStream::LittleEndian);
         quint16 groupId = 0; quint8 sceneId;
         payloadStream >> groupId >> sceneId;
diff --git a/libnymea-zigbee/zcl/security/zigbeeclusteriaswd.cpp b/libnymea-zigbee/zcl/security/zigbeeclusteriaswd.cpp
index ae6bb0e..8631ee1 100644
--- a/libnymea-zigbee/zcl/security/zigbeeclusteriaswd.cpp
+++ b/libnymea-zigbee/zcl/security/zigbeeclusteriaswd.cpp
@@ -40,7 +40,11 @@ ZigbeeClusterIasWd::ZigbeeClusterIasWd(ZigbeeNetwork *network, ZigbeeNode *node,
 ZigbeeClusterReply *ZigbeeClusterIasWd::startWarning(WarningMode warningMode, bool strobeEnabled, SirenLevel sirenLevel, quint16 duration, quint8 strobeDutyCycle, StrobeLevel strobeLevel)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << static_cast<quint8>(warningMode | (strobeEnabled ? 0x04 : 0x00) | sirenLevel);
     stream << duration;
@@ -55,7 +59,11 @@ ZigbeeClusterReply *ZigbeeClusterIasWd::startWarning(WarningMode warningMode, bo
 ZigbeeClusterReply *ZigbeeClusterIasWd::squawk(SquawkMode squawkMode, bool strobeEnabled, SquawkLevel squawkLevel)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << static_cast<quint8>(squawkMode | (strobeEnabled ? 0x08 : 0x00) | squawkLevel);
     qCDebug(dcZigbeeCluster) << "Sending payload:" << payload.toHex();
diff --git a/libnymea-zigbee/zcl/zigbeeclusterlibrary.cpp b/libnymea-zigbee/zcl/zigbeeclusterlibrary.cpp
index b973a72..681f1a1 100644
--- a/libnymea-zigbee/zcl/zigbeeclusterlibrary.cpp
+++ b/libnymea-zigbee/zcl/zigbeeclusterlibrary.cpp
@@ -80,7 +80,12 @@ ZigbeeClusterLibrary::FrameControl ZigbeeClusterLibrary::parseFrameControlByte(q
 QByteArray ZigbeeClusterLibrary::buildHeader(const ZigbeeClusterLibrary::Header &header)
 {
     QByteArray headerData;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&headerData, QDataStream::WriteOnly);
+#else
     QDataStream stream(&headerData, QIODevice::WriteOnly);
+#endif
+
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << buildFrameControlByte(header.frameControl);
 
@@ -144,7 +149,11 @@ QList<ZigbeeClusterLibrary::ReadAttributeStatusRecord> ZigbeeClusterLibrary::par
 ZigbeeDataType ZigbeeClusterLibrary::readDataType(QDataStream *stream, Zigbee::DataType dataType)
 {
     QByteArray data; quint16 numberOfElenemts = 0; quint8 elementType = 0;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream dataStream(&data, QDataStream::WriteOnly);
+#else
     QDataStream dataStream(&data, QIODevice::WriteOnly);
+#endif
     dataStream.setByteOrder(QDataStream::LittleEndian);
 
     // Parse data depending on the type
@@ -257,7 +266,11 @@ QByteArray ZigbeeClusterLibrary::buildFrame(const ZigbeeClusterLibrary::Frame &f
 QByteArray ZigbeeClusterLibrary::buildAttributeReportingConfiguration(const ZigbeeClusterLibrary::AttributeReportingConfiguration &reportingConfiguration)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << static_cast<quint8>(reportingConfiguration.direction);
     stream << reportingConfiguration.attributeId;
@@ -265,7 +278,7 @@ QByteArray ZigbeeClusterLibrary::buildAttributeReportingConfiguration(const Zigb
     stream << reportingConfiguration.minReportingInterval;
     stream << reportingConfiguration.maxReportingInterval;
 
-    for (int i = 0; i < reportingConfiguration.reportableChange.count(); i++) {
+    for (int i = 0; i < reportingConfiguration.reportableChange.size(); i++) {
         stream << static_cast<quint8>(reportingConfiguration.reportableChange.at(i));
     }
 
@@ -280,11 +293,15 @@ QByteArray ZigbeeClusterLibrary::buildAttributeReportingConfiguration(const Zigb
 QByteArray ZigbeeClusterLibrary::buildWriteAttributeRecord(const ZigbeeClusterLibrary::WriteAttributeRecord &writeAttributeRecord)
 {
     QByteArray payload;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&payload, QDataStream::WriteOnly);
+#else
     QDataStream stream(&payload, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << writeAttributeRecord.attributeId;
     stream << static_cast<quint8>(writeAttributeRecord.dataType);
-    for (int i = 0; i < writeAttributeRecord.data.count(); i++) {
+    for (int i = 0; i < writeAttributeRecord.data.size(); i++) {
         stream << static_cast<quint8>(writeAttributeRecord.data.at(i));
     }
 
diff --git a/libnymea-zigbee/zigbeedatatype.cpp b/libnymea-zigbee/zigbeedatatype.cpp
index 596533f..849f586 100644
--- a/libnymea-zigbee/zigbeedatatype.cpp
+++ b/libnymea-zigbee/zigbeedatatype.cpp
@@ -174,7 +174,11 @@ ZigbeeDataType::ZigbeeDataType(quint8 value)
 {
     setDataType(Zigbee::Uint8);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 }
@@ -183,7 +187,11 @@ ZigbeeDataType::ZigbeeDataType(quint16 value)
 {
     setDataType(Zigbee::Uint16);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 }
@@ -193,7 +201,11 @@ ZigbeeDataType::ZigbeeDataType(quint32 value, Zigbee::DataType dataType)
     Q_ASSERT_X(dataType == Zigbee::Uint24 || dataType == Zigbee::Uint32, "ZigbeeDataType", "invalid data type for quint32 constructor");
     setDataType(dataType);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 
@@ -207,7 +219,11 @@ ZigbeeDataType::ZigbeeDataType(quint64 value, Zigbee::DataType dataType)
     Q_ASSERT_X(dataType == Zigbee::Uint40 || dataType == Zigbee::Uint48 || dataType == Zigbee::Uint56 || dataType == Zigbee::Uint64, "ZigbeeDataType", "invalid data type for quint64 constructor");
     setDataType(dataType);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 
@@ -224,7 +240,11 @@ ZigbeeDataType::ZigbeeDataType(qint8 value)
 {
     setDataType(Zigbee::Int8);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 }
@@ -233,7 +253,11 @@ ZigbeeDataType::ZigbeeDataType(qint16 value)
 {
     setDataType(Zigbee::Int16);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 }
@@ -243,7 +267,11 @@ ZigbeeDataType::ZigbeeDataType(qint32 value, Zigbee::DataType dataType)
     Q_ASSERT_X(dataType == Zigbee::Int24 || dataType == Zigbee::Int32, "ZigbeeDataType", "invalid data type for qint32 constructor");
     setDataType(dataType);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 
@@ -257,7 +285,11 @@ ZigbeeDataType::ZigbeeDataType(qint64 value, Zigbee::DataType dataType)
     Q_ASSERT_X(dataType == Zigbee::Int40 || dataType == Zigbee::Int48 || dataType == Zigbee::Int56 || dataType == Zigbee::Int64, "ZigbeeDataType", "invalid data type for qint64 constructor");
     setDataType(dataType);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << value;
 
@@ -274,7 +306,11 @@ ZigbeeDataType::ZigbeeDataType(bool value)
 {
     setDataType(Zigbee::Bool);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
     stream << (value ? static_cast<quint8>(1) : static_cast<quint8>(0));
 }
@@ -284,7 +320,11 @@ ZigbeeDataType::ZigbeeDataType(const QString &value, Zigbee::DataType dataType)
     Q_ASSERT_X(dataType == Zigbee::OctetString || dataType == Zigbee::CharString || dataType == Zigbee::LongOctetString || dataType == Zigbee::LongCharString, "ZigbeeDataType", "invalid data type for QString constructor");
     setDataType(dataType);
     m_data.clear();
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&m_data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&m_data, QIODevice::WriteOnly);
+#endif
     stream.setByteOrder(QDataStream::LittleEndian);
 
     if (dataType == Zigbee::OctetString || dataType == Zigbee::CharString) {
@@ -305,7 +345,7 @@ ZigbeeDataType::ZigbeeDataType(const QString &value, Zigbee::DataType dataType)
 quint8 ZigbeeDataType::toUInt8(bool *ok) const
 {
     if (ok) *ok = true;
-    if (m_data.count() != 1) {
+    if (m_data.size() != 1) {
         if (ok) *ok = false;
         return 0;
     }
@@ -318,7 +358,7 @@ quint16 ZigbeeDataType::toUInt16(bool *ok) const
     if (ok) *ok = true;
 
     quint16 value = 0;
-    if (m_data.count() != 2) {
+    if (m_data.size() != 2) {
         if (ok) *ok = false;
         return value;
     }
@@ -341,12 +381,12 @@ quint32 ZigbeeDataType::toUInt32(bool *ok) const
     }
 
     // Make sure there is enought data
-    if (m_data.count() != 3 && m_data.count() != 4) {
+    if (m_data.size() != 3 && m_data.size() != 4) {
         if (ok) *ok = false;
         return value;
     }
 
-    if (m_data.count() == 3) {
+    if (m_data.size() == 3) {
         // Make it 32 bit for converting
         QByteArray convertedData(m_data);
         convertedData.append(static_cast<char>(0));
@@ -369,7 +409,7 @@ quint64 ZigbeeDataType::toUInt64(bool *ok) const
 
     switch (m_dataType) {
     case Zigbee::Uint40: {
-        if (m_data.count() != 5) {
+        if (m_data.size() != 5) {
             if (ok) *ok = false;
             break;
         }
@@ -385,7 +425,7 @@ quint64 ZigbeeDataType::toUInt64(bool *ok) const
         break;
     }
     case Zigbee::Uint48: {
-        if (m_data.count() != 6) {
+        if (m_data.size() != 6) {
             if (ok) *ok = false;
             break;
         }
@@ -401,7 +441,7 @@ quint64 ZigbeeDataType::toUInt64(bool *ok) const
         break;
     }
     case Zigbee::Uint56: {
-        if (m_data.count() != 7) {
+        if (m_data.size() != 7) {
             if (ok) *ok = false;
             break;
         }
@@ -415,7 +455,7 @@ quint64 ZigbeeDataType::toUInt64(bool *ok) const
         break;
     }
     case Zigbee::Uint64: {
-        if (m_data.count() != 8) {
+        if (m_data.size() != 8) {
             if (ok) *ok = false;
             break;
         }
@@ -436,7 +476,7 @@ quint64 ZigbeeDataType::toUInt64(bool *ok) const
 qint8 ZigbeeDataType::toInt8(bool *ok) const
 {
     if (ok) *ok = true;
-    if (m_data.count() != 1) {
+    if (m_data.size() != 1) {
         if (ok) *ok = false;
         return 0;
     }
@@ -449,7 +489,7 @@ qint16 ZigbeeDataType::toInt16(bool *ok) const
     if (ok) *ok = true;
 
     qint16 value = 0;
-    if (m_data.count() != 2 || m_dataType != Zigbee::Int16) {
+    if (m_data.size() != 2 || m_dataType != Zigbee::Int16) {
         if (ok) *ok = false;
         return value;
     }
@@ -472,12 +512,12 @@ qint32 ZigbeeDataType::toInt32(bool *ok) const
     }
 
     // Make sure there is enought data
-    if (m_data.count() != 3 && m_data.count() != 4) {
+    if (m_data.size() != 3 && m_data.size() != 4) {
         if (ok) *ok = false;
         return value;
     }
 
-    if (m_data.count() == 3) {
+    if (m_data.size() == 3) {
         // Make it 32 bit for converting
         QByteArray convertedData(m_data);
         convertedData.append(static_cast<char>(0));
@@ -500,7 +540,7 @@ qint64 ZigbeeDataType::toInt64(bool *ok) const
 
     switch (m_dataType) {
     case Zigbee::Int40: {
-        if (m_data.count() != 5) {
+        if (m_data.size() != 5) {
             if (ok) *ok = false;
             break;
         }
@@ -516,7 +556,7 @@ qint64 ZigbeeDataType::toInt64(bool *ok) const
         break;
     }
     case Zigbee::Int48: {
-        if (m_data.count() != 6) {
+        if (m_data.size() != 6) {
             if (ok) *ok = false;
             break;
         }
@@ -532,7 +572,7 @@ qint64 ZigbeeDataType::toInt64(bool *ok) const
         break;
     }
     case Zigbee::Int56: {
-        if (m_data.count() != 7) {
+        if (m_data.size() != 7) {
             if (ok) *ok = false;
             break;
         }
@@ -546,7 +586,7 @@ qint64 ZigbeeDataType::toInt64(bool *ok) const
         break;
     }
     case Zigbee::Int64: {
-        if (m_data.count() != 8) {
+        if (m_data.size() != 8) {
             if (ok) *ok = false;
             break;
         }
@@ -569,7 +609,7 @@ bool ZigbeeDataType::toBool(bool *ok) const
     if (ok) *ok = true;
     bool value = false;
 
-    if (m_data.count() != 1) {
+    if (m_data.size() != 1) {
         if (ok) *ok = false;
         return value;
     }
diff --git a/libnymea-zigbee/zigbeedatatype.h b/libnymea-zigbee/zigbeedatatype.h
index f10ab2a..d241280 100644
--- a/libnymea-zigbee/zigbeedatatype.h
+++ b/libnymea-zigbee/zigbeedatatype.h
@@ -30,7 +30,6 @@
 
 #include "zigbee.h"
 
-
 class ZigbeeDataType
 {
 public:
diff --git a/libnymea-zigbee/zigbeenetworkdatabase.cpp b/libnymea-zigbee/zigbeenetworkdatabase.cpp
index 608f0c3..96a7f07 100644
--- a/libnymea-zigbee/zigbeenetworkdatabase.cpp
+++ b/libnymea-zigbee/zigbeenetworkdatabase.cpp
@@ -74,7 +74,12 @@ QList<ZigbeeNode *> ZigbeeNetworkDatabase::loadNodes()
     qCDebug(dcZigbeeNetworkDatabase()) << "Loading nodes from database" << m_db.databaseName();
     QList<ZigbeeNode *> nodes;
     QString query("SELECT * FROM nodes;");
-    QSqlQuery nodesQuery = m_db.exec(query);
+    QSqlQuery nodesQuery(query, m_db);
+    if (!nodesQuery.exec()) {
+        qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+        return QList<ZigbeeNode *>();
+    }
+
     while (nodesQuery.next()) {
         QString ieeeAddress = nodesQuery.value("ieeeAddress").toString();
         quint16 shortAddress = nodesQuery.value("shortAddress").toUInt();
@@ -101,7 +106,13 @@ QList<ZigbeeNode *> ZigbeeNetworkDatabase::loadNodes()
 
         // Now load all endpoints for this node
         query = QString("SELECT * FROM endpoints WHERE ieeeAddress = \"%1\";").arg(ieeeAddress);
-        QSqlQuery endpointsQuery = m_db.exec(query);
+
+        QSqlQuery endpointsQuery(query, m_db);
+        if (!endpointsQuery.exec()) {
+            qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+            return QList<ZigbeeNode *>();
+        }
+
         while (endpointsQuery.next()) {
             quint8 endpointId = endpointsQuery.value("endpointId").toUInt();
             ZigbeeNodeEndpoint *endpoint = new ZigbeeNodeEndpoint(m_network, node, endpointId, node);
@@ -115,7 +126,13 @@ QList<ZigbeeNode *> ZigbeeNetworkDatabase::loadNodes()
             query = QString("SELECT * FROM serverClusters WHERE endpointId = (SELECT id FROM endpoints WHERE ieeeAddress = \"%1\" AND endpointId = \"%2\");")
                     .arg(ieeeAddress)
                     .arg(endpointId);
-            QSqlQuery inputClustersQuery = m_db.exec(query);
+
+            QSqlQuery inputClustersQuery(query, m_db);
+            if (!inputClustersQuery.exec()) {
+                qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+                return QList<ZigbeeNode *>();
+            }
+
             while (inputClustersQuery.next()) {
                 ZigbeeClusterLibrary::ClusterId clusterId = static_cast<ZigbeeClusterLibrary::ClusterId>(inputClustersQuery.value("clusterId").toUInt());
                 ZigbeeCluster *cluster = endpoint->createCluster(clusterId, ZigbeeCluster::Server);
@@ -128,13 +145,18 @@ QList<ZigbeeNode *> ZigbeeNetworkDatabase::loadNodes()
                         .arg(ieeeAddress)
                         .arg(endpointId)
                         .arg(cluster->clusterId());
-                QSqlQuery attributesQuery = m_db.exec(query);
+
+                QSqlQuery attributesQuery(query, m_db);
+                if (!attributesQuery.exec()) {
+                    qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+                    return QList<ZigbeeNode *>();
+                }
+
                 if (m_db.lastError().type() != QSqlError::NoError) {
                     qCWarning(dcZigbeeNetworkDatabase()) << "Could not fetch attributes from database entries." << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
                     continue;
                 }
 
-
                 while (attributesQuery.next()) {
                     quint16 attributeId = attributesQuery.value("attributeId").toUInt();
                     Zigbee::DataType type = static_cast<Zigbee::DataType>(attributesQuery.value("dataType").toUInt());
@@ -169,7 +191,13 @@ QList<ZigbeeNode *> ZigbeeNetworkDatabase::loadNodes()
             query = QString("SELECT * FROM clientClusters WHERE endpointId = (SELECT id FROM endpoints WHERE ieeeAddress = \"%1\" AND endpointId = \"%2\");")
                     .arg(ieeeAddress)
                     .arg(endpointId);
-            QSqlQuery outputClustersQuery = m_db.exec(query);
+
+            QSqlQuery outputClustersQuery(query, m_db);
+            if (!outputClustersQuery.exec()) {
+                qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+                return QList<ZigbeeNode *>();
+            }
+
             while (outputClustersQuery.next()) {
                 ZigbeeClusterLibrary::ClusterId clusterId = static_cast<ZigbeeClusterLibrary::ClusterId>(outputClustersQuery.value("clusterId").toUInt());
                 ZigbeeCluster *cluster = endpoint->createCluster(clusterId, ZigbeeCluster::Client);
@@ -207,11 +235,17 @@ bool ZigbeeNetworkDatabase::wipeDatabase()
 {
     qCDebug(dcZigbeeNetworkDatabase()) << "Wipe all database entries from" << m_db.databaseName();
     // Note: cascade will clean all other tables
-    m_db.exec("DELETE FROM nodes;");
+    QSqlQuery deleteQuery("DELETE FROM nodes;", m_db);
+    if (!deleteQuery.exec()) {
+        qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << deleteQuery.lastQuery() << m_db.lastError().databaseText() << m_db.lastError().driverText();
+        return false;
+    }
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not delete all node database entries." << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
     }
+
     m_db.close();
     m_db = QSqlDatabase();
     QSqlDatabase::removeDatabase(m_connectionName);
@@ -237,14 +271,22 @@ bool ZigbeeNetworkDatabase::initDatabase()
         return false;
     }
 
-
-    // FIXME: check schema version fro compatibility or migration
+    // TODO: check schema version fro compatibility or migration
 
     qCDebug(dcZigbeeNetworkDatabase()) << "Tables" << m_db.tables();
     if (m_db.tables().isEmpty()) {
         // Write pragmas
-        m_db.exec("PRAGMA foreign_keys = ON;");
-        m_db.exec(QString("PRAGMA user_version = %1;").arg(DB_VERSION));
+        QSqlQuery enableForeigenKeysQuery("PRAGMA foreign_keys = ON;", m_db);
+        if (!enableForeigenKeysQuery.exec()) {
+            qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << enableForeigenKeysQuery.lastQuery() << m_db.lastError().databaseText() << m_db.lastError().driverText();
+            return false;
+        }
+
+        QSqlQuery setUserVersionQuery(QString("PRAGMA user_version = %1;").arg(DB_VERSION), m_db);
+        if (!setUserVersionQuery.exec()) {
+            qCWarning(dcZigbeeNetworkDatabase()) << "Unable to execute SQL query" << enableForeigenKeysQuery.lastQuery() << m_db.lastError().databaseText() << m_db.lastError().driverText();
+            return false;
+        }
     }
 
     // Create nodes table
@@ -323,7 +365,9 @@ void ZigbeeNetworkDatabase::createTable(const QString &tableName, const QString
 {
     qCDebug(dcZigbeeNetworkDatabase()) << "Creating table" << tableName << schema;
     QString query = QString("CREATE TABLE IF NOT EXISTS %1 %2;").arg(tableName).arg(schema);
-    m_db.exec(query);
+    QSqlQuery createTableQuery(query, m_db);
+    createTableQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not create table in database." << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return;
@@ -333,7 +377,13 @@ void ZigbeeNetworkDatabase::createTable(const QString &tableName, const QString
 void ZigbeeNetworkDatabase::createIndices(const QString &indexName, const QString &tableName, const QString &columns)
 {
     qCDebug(dcZigbeeNetworkDatabase()) << "Creating table indices" << indexName << tableName << columns;
-    m_db.exec(QString("CREATE UNIQUE INDEX IF NOT EXISTS %1 ON %2(%3);").arg(indexName).arg(tableName).arg(columns));
+    QString query = QString("CREATE UNIQUE INDEX IF NOT EXISTS %1 ON %2(%3);").arg(indexName).arg(tableName).arg(columns);
+    QSqlQuery createTableQuery(query, m_db);
+    createTableQuery.exec();
+    if (m_db.lastError().type() != QSqlError::NoError) {
+        qCWarning(dcZigbeeNetworkDatabase()) << "Could not create indices in database." << query << m_db.lastError().databaseText() << m_db.lastError().driverText();
+        return;
+    }
 }
 
 bool ZigbeeNetworkDatabase::saveNodeEndpoint(ZigbeeNodeEndpoint *endpoint)
@@ -348,7 +398,8 @@ bool ZigbeeNetworkDatabase::saveNodeEndpoint(ZigbeeNodeEndpoint *endpoint)
             .arg(static_cast<quint8>(endpoint->deviceVersion()));
 
     qCDebug(dcZigbeeNetworkDatabase()) << queryString;
-    m_db.exec(queryString);
+    QSqlQuery saveNodeEndpointQuery(queryString, m_db);
+    saveNodeEndpointQuery.exec();
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not save endpoint into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -385,7 +436,9 @@ bool ZigbeeNetworkDatabase::saveInputCluster(ZigbeeCluster *cluster)
     QString queryString = QString("INSERT OR REPLACE INTO serverClusters (endpointId, clusterId) VALUES (%1, \"%2\");")
             .arg(endpointIdReferenceQuery)
             .arg(static_cast<quint16>(cluster->clusterId()));
-    m_db.exec(queryString);
+
+    QSqlQuery saveInputClusterQuery(queryString, m_db);
+    saveInputClusterQuery.exec();
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not save input cluster into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -404,7 +457,8 @@ bool ZigbeeNetworkDatabase::saveOutputCluster(ZigbeeCluster *cluster)
             .arg(endpointIdReferenceQuery)
             .arg(static_cast<quint16>(cluster->clusterId()));
 
-    m_db.exec(queryString);
+    QSqlQuery saveOutputClusterQuery(queryString, m_db);
+    saveOutputClusterQuery.exec();
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not save output cluster into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -430,9 +484,11 @@ bool ZigbeeNetworkDatabase::saveAttribute(ZigbeeCluster *cluster, const ZigbeeCl
             .arg(static_cast<quint8>(attribute.dataType().dataType()))
             .arg((attribute.dataType().data().toBase64().data()));
 
-    m_db.exec(queryString);
+    QSqlQuery saveClusterAttributeQuery(queryString, m_db);
+    saveClusterAttributeQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
-        qCWarning(dcZigbeeNetworkDatabase()) << "Could not save cluster cluster attribute into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
+        qCWarning(dcZigbeeNetworkDatabase()) << "Could not save cluster attribute into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
     }
 
@@ -452,7 +508,10 @@ bool ZigbeeNetworkDatabase::saveNode(ZigbeeNode *node)
             .arg(node->lastSeen().toMSecsSinceEpoch() / 1000);
 
     qCDebug(dcZigbeeNetworkDatabase()) << queryString;
-    m_db.exec(queryString);
+
+    QSqlQuery saveNodeQuery(queryString, m_db);
+    saveNodeQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not save node into database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -474,7 +533,9 @@ bool ZigbeeNetworkDatabase::updateNodeLqi(ZigbeeNode *node, quint8 lqi)
 {
     qCDebug(dcZigbeeNetworkDatabase()) << "Update node LQI" << node << lqi;
     QString queryString = QString("UPDATE nodes SET lqi = \"%1\" WHERE ieeeAddress = \"%2\";").arg(lqi).arg(node->extendedAddress().toString());
-    m_db.exec(queryString);
+    QSqlQuery updateNodeLqiQuery(queryString, m_db);
+    updateNodeLqiQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not update node LQI value in the database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -487,7 +548,9 @@ bool ZigbeeNetworkDatabase::updateNodeNetworkAddress(ZigbeeNode *node, quint16 n
 {
     qCDebug(dcZigbeeNetworkDatabase()) << "Update node network address" << node << ZigbeeUtils::convertUint16ToHexString(networkAddress);
     QString queryString = QString("UPDATE nodes SET shortAddress = \"%1\" WHERE ieeeAddress = \"%2\";").arg(networkAddress).arg(node->extendedAddress().toString());
-    m_db.exec(queryString);
+    QSqlQuery updateNodeNetworkAddressQuery(queryString, m_db);
+    updateNodeNetworkAddressQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not update node LQI value in the database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -501,7 +564,9 @@ bool ZigbeeNetworkDatabase::updateNodeLastSeen(ZigbeeNode *node, const QDateTime
     quint64 timestamp = lastSeen.toMSecsSinceEpoch() / 1000;
     qCDebug(dcZigbeeNetworkDatabase()) << "Update node last seen UTC timestamp" << node << timestamp;
     QString queryString = QString("UPDATE nodes SET timestamp = \"%1\" WHERE ieeeAddress = \"%2\";").arg(timestamp).arg(node->extendedAddress().toString());
-    m_db.exec(queryString);
+    QSqlQuery updateNodeLastSeenQuery(queryString, m_db);
+    updateNodeLastSeenQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not update node timestamp value in the database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
@@ -546,7 +611,9 @@ bool ZigbeeNetworkDatabase::removeNode(ZigbeeNode *node)
     qCDebug(dcZigbeeNetworkDatabase()) << "Remove" << node;
     // Note: cascade delete will clean up all other tables
     QString queryString = QString("DELETE FROM nodes WHERE ieeeAddress = \"%1\";").arg(node->extendedAddress().toString());
-    m_db.exec(queryString);
+    QSqlQuery removeNodeQuery(queryString, m_db);
+    removeNodeQuery.exec();
+
     if (m_db.lastError().type() != QSqlError::NoError) {
         qCWarning(dcZigbeeNetworkDatabase()) << "Could not remove node from database." << queryString << m_db.lastError().databaseText() << m_db.lastError().driverText();
         return false;
diff --git a/libnymea-zigbee/zigbeenetworkkey.cpp b/libnymea-zigbee/zigbeenetworkkey.cpp
index a79b4e9..b291f2b 100644
--- a/libnymea-zigbee/zigbeenetworkkey.cpp
+++ b/libnymea-zigbee/zigbeenetworkkey.cpp
@@ -45,7 +45,7 @@ ZigbeeNetworkKey::ZigbeeNetworkKey(const QString &keyString)
     if (rawKey.isEmpty())
         return;
 
-    Q_ASSERT_X(rawKey.count() == 32, "ZigbeeNetworkKey", "invalid key length in ZigbeeNetworkKey(QString).");
+    Q_ASSERT_X(rawKey.size() == 32, "ZigbeeNetworkKey", "invalid key length in ZigbeeNetworkKey(QString).");
     m_key = QByteArray::fromHex(rawKey.toLatin1());
 }
 
@@ -57,7 +57,7 @@ ZigbeeNetworkKey::ZigbeeNetworkKey(const QByteArray &key) :
 
 bool ZigbeeNetworkKey::isValid() const
 {
-    return m_key.count() == 16;
+    return m_key.size() == 16;
 }
 
 bool ZigbeeNetworkKey::isNull() const
@@ -88,7 +88,12 @@ QByteArray ZigbeeNetworkKey::toByteArray() const
 ZigbeeNetworkKey ZigbeeNetworkKey::generateKey()
 {
     QByteArray keyData;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&keyData, QDataStream::WriteOnly);
+#else
     QDataStream stream(&keyData, QIODevice::WriteOnly);
+#endif
+
     for (int i = 0; i < 16; i++) {
         stream << static_cast<quint8>(rand() % (256 - 1) + 1);
     }
diff --git a/libnymea-zigbee/zigbeeuartadaptermonitor.cpp b/libnymea-zigbee/zigbeeuartadaptermonitor.cpp
index 19513be..fe6173a 100644
--- a/libnymea-zigbee/zigbeeuartadaptermonitor.cpp
+++ b/libnymea-zigbee/zigbeeuartadaptermonitor.cpp
@@ -29,6 +29,7 @@
 #include "loggingcategory.h"
 
 #include <QSerialPortInfo>
+#include <QRegularExpression>
 
 #ifndef DISABLE_UDEV
 #include <libudev.h>
@@ -238,7 +239,7 @@ void ZigbeeUartAdapterMonitor::addAdapterInternally(const QString &serialPort)
             adapter.setBaudRate(115200);
         }
         QStringList zStackModels = {"cc2530", "cc2531", "cc2538", "cc1352p", "cc2652p", "cc2652r", "cc2652rb", "sonoff zigbee 3.0 usb"};
-        if (QRegExp(".*(" + zStackModels.join("|") + ").*").exactMatch(serialPortInfo.description().toLower())) {
+        if (QRegularExpression(".*(" + zStackModels.join("|") + ").*").match(serialPortInfo.description().toLower()).hasMatch()) {
             adapter.setHardwareRecognized(true);
             adapter.setBackendType(Zigbee::ZigbeeBackendTypeTi);
             adapter.setBaudRate(115200);
diff --git a/libnymea-zigbee/zigbeeutils.cpp b/libnymea-zigbee/zigbeeutils.cpp
index 040347e..7c2ef26 100644
--- a/libnymea-zigbee/zigbeeutils.cpp
+++ b/libnymea-zigbee/zigbeeutils.cpp
@@ -134,10 +134,10 @@ static QList<QColor> colorTemperatureScale = {
 
 QBitArray ZigbeeUtils::convertByteArrayToBitArray(const QByteArray &byteArray)
 {
-    QBitArray bitArray(byteArray.count() * 8);
+    QBitArray bitArray(byteArray.size() * 8);
 
     // Convert from QByteArray to QBitArray
-    for(int i = 0; i < byteArray.count(); ++i) {
+    for(int i = 0; i < byteArray.size(); ++i) {
         for(int b = 0; b < 8; b++) {
             bitArray.setBit(i * 8 + b, byteArray.at(i) & (1 << ( 7 - b)));
         }
@@ -168,7 +168,7 @@ bool ZigbeeUtils::checkBitUint16(const quint16 &value, const int &bitNumber)
 
 quint16 ZigbeeUtils::convertByteArrayToUint16(const QByteArray &data)
 {
-    Q_ASSERT_X(data.count() == 2, "converting data", "Invalid byte array size for converting to quint16");
+    Q_ASSERT_X(data.size() == 2, "converting data", "Invalid byte array size for converting to quint16");
 
     quint16 value = static_cast<quint8>(data.at(0));
     value <<= 8;
@@ -178,7 +178,7 @@ quint16 ZigbeeUtils::convertByteArrayToUint16(const QByteArray &data)
 
 quint64 ZigbeeUtils::convertByteArrayToUint64(const QByteArray &data)
 {
-    Q_ASSERT_X(data.count() == 8, "converting data", "Invalid byte array size for converting to quint64");
+    Q_ASSERT_X(data.size() == 8, "converting data", "Invalid byte array size for converting to quint64");
 
     quint64 value = static_cast<quint8>(data.at(0));
     value <<= 8;
@@ -208,9 +208,9 @@ QString ZigbeeUtils::convertByteToHexString(const quint8 &byte)
 QString ZigbeeUtils::convertByteArrayToHexString(const QByteArray &byteArray)
 {
     QString hexString;
-    for (int i = 0; i < byteArray.count(); i++) {
+    for (int i = 0; i < byteArray.size(); i++) {
         hexString.append(convertByteToHexString(static_cast<quint8>(byteArray.at(i))));
-        if (i != byteArray.count() - 1) {
+        if (i != byteArray.size() - 1) {
             hexString.append(" ");
         }
     }
@@ -220,7 +220,11 @@ QString ZigbeeUtils::convertByteArrayToHexString(const QByteArray &byteArray)
 QString ZigbeeUtils::convertUint16ToHexString(const quint16 &value)
 {
     QByteArray data;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&data, QIODevice::WriteOnly);
+#endif
     stream << value;
 
     return QString("0x%1").arg(convertByteArrayToHexString(data).remove(" ").remove("0x"));
@@ -229,7 +233,11 @@ QString ZigbeeUtils::convertUint16ToHexString(const quint16 &value)
 QString ZigbeeUtils::convertUint32ToHexString(const quint32 &value)
 {
     QByteArray data;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&data, QIODevice::WriteOnly);
+#endif
     stream << value;
 
     return QString("0x%1").arg(convertByteArrayToHexString(data).remove(" ").remove("0x"));
@@ -238,7 +246,11 @@ QString ZigbeeUtils::convertUint32ToHexString(const quint32 &value)
 QString ZigbeeUtils::convertUint64ToHexString(const quint64 &value)
 {
     QByteArray data;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    QDataStream stream(&data, QDataStream::WriteOnly);
+#else
     QDataStream stream(&data, QIODevice::WriteOnly);
+#endif
     stream << value;
     return QString("0x%1").arg(convertByteArrayToHexString(data).remove(" ").remove("0x"));
 }