ETM-Schurig
/
nymea-plugins
mirror of https://github.com/nymea/nymea-plugins.git
1
0
Fork 0
Code Issues 1 Packages Projects Releases Wiki Activity
nymea-plugins/tplink/integrationplugintplink.cpp

625 lines
26 KiB
C++
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-3.0-or-later
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright (C) 2013 - 2024, nymea GmbH
* Copyright (C) 2024 - 2025, chargebyte austria GmbH
*
* This file is part of nymea-plugins.
*
* nymea-plugins is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* nymea-plugins is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with nymea-plugins. If not, see <https://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "integrationplugintplink.h"
#include "plugininfo.h"
#include <network/networkaccessmanager.h>
#include <plugintimer.h>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QTimer>
#include <QDataStream>
#include <QRegularExpression>
// Related projects:
// Local api:
// https://github.com/plasticrake/tplink-smarthome-api/
// https://github.com/softScheck/tplink-smartplug
// Cloud api:
// https://github.com/piekstra/tplink-cloud-api/
QHash<ThingClassId, ParamTypeId> idParamTypesMap = {
{kasaPlug100ThingClassId, kasaPlug100ThingIdParamTypeId},
{kasaPlug110ThingClassId, kasaPlug110ThingIdParamTypeId},
{kasaSwitch200ThingClassId, kasaSwitch200ThingIdParamTypeId},
{kasaPowerStrip300ThingClassId, kasaPowerStrip300ThingIdParamTypeId},
};
QHash<ThingClassId, StateTypeId> connectedStateTypesMap = {
{kasaPlug100ThingClassId, kasaPlug100ConnectedStateTypeId},
{kasaPlug110ThingClassId, kasaPlug110ConnectedStateTypeId},
{kasaSwitch200ThingClassId, kasaSwitch200ConnectedStateTypeId},
{kasaPowerStrip300ThingClassId, kasaPowerStrip300ConnectedStateTypeId},
};
QHash<ThingClassId, StateTypeId> signalStrengthStateTypesMap = {
{kasaPlug100ThingClassId, kasaPlug100SignalStrengthStateTypeId},
{kasaPlug110ThingClassId, kasaPlug110SignalStrengthStateTypeId},
{kasaSwitch200ThingClassId, kasaSwitch200SignalStrengthStateTypeId},
{kasaPowerStrip300ThingClassId, kasaPowerStrip300SignalStrengthStateTypeId},
};
QHash<ThingClassId, StateTypeId> powerStateTypesMap = {
{kasaPlug100ThingClassId, kasaPlug100PowerStateTypeId},
{kasaPlug110ThingClassId, kasaPlug110PowerStateTypeId},
{kasaSwitch200ThingClassId, kasaSwitch200PowerStateTypeId},
};
QHash<ThingClassId, StateTypeId> currentPowerStatetTypesMap = {
{kasaPlug110ThingClassId, kasaPlug110CurrentPowerStateTypeId},
{kasaPowerStrip300ThingClassId, kasaPowerStrip300CurrentPowerStateTypeId},
};
QHash<ThingClassId, StateTypeId> totalEnergyConsumedStatetTypesMap = {
{kasaPlug110ThingClassId, kasaPlug110TotalEnergyConsumedStateTypeId},
{kasaPowerStrip300ThingClassId, kasaPowerStrip300TotalEnergyConsumedStateTypeId},
};
QHash<ThingClassId, StateTypeId> powerActionParamTypesMap = {
{kasaPlug100ThingClassId, kasaPlug100PowerActionPowerParamTypeId},
{kasaPlug110ThingClassId, kasaPlug110PowerActionPowerParamTypeId},
{kasaSwitch200ThingClassId, kasaSwitch200PowerActionPowerParamTypeId},
};
IntegrationPluginTPLink::IntegrationPluginTPLink()
{
}
IntegrationPluginTPLink::~IntegrationPluginTPLink()
{
}
void IntegrationPluginTPLink::init()
{
m_broadcastSocket = new QUdpSocket(this);
}
void IntegrationPluginTPLink::discoverThings(ThingDiscoveryInfo *info)
{
QVariantMap map;
QVariantMap getSysInfo;
getSysInfo.insert("get_sysinfo", QVariant());
map.insert("system", getSysInfo);
QByteArray payload = QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact);
QByteArray datagram = encryptPayload(payload);
qint64 len = m_broadcastSocket->writeDatagram(datagram, QHostAddress::Broadcast, 9999);
if (len != datagram.length()) {
info->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("An error happened sending the discovery to the network."));
return;
}
QTimer::singleShot(2000, info, [this, info](){
while(m_broadcastSocket->hasPendingDatagrams()) {
char buffer[4096];
QHostAddress senderAddress;
qint64 len = m_broadcastSocket->readDatagram(buffer, 4096, &senderAddress);
QByteArray data = decryptPayload(QByteArray::fromRawData(buffer, len));
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcTplink()) << "Error parsing JSON from thing:" << data;
continue;
}
QVariantMap properties = jsonDoc.toVariant().toMap();
QVariantMap sysInfo = properties.value("system").toMap().value("get_sysinfo").toMap();
qCWarning(dcTplink()) << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented));
QRegularExpression modelFilter;
if (info->thingClassId() == kasaPlug100ThingClassId) {
modelFilter = QRegularExpression("(HS100|HS103|HS105|KP100|KP105).*");
} else if (info->thingClassId() == kasaPlug110ThingClassId) {
modelFilter = QRegularExpression("(HS110|KP115).*");
} else if (info->thingClassId() == kasaSwitch200ThingClassId) {
modelFilter = QRegularExpression("HS200.*");
} else if (info->thingClassId() == kasaPowerStrip300ThingClassId) {
modelFilter = QRegularExpression("HS300.*");
}
QString model = sysInfo.value("model").toString();
if (modelFilter.match(model).hasMatch()) {
ThingDescriptor descriptor(info->thingClassId(), sysInfo.value("alias").toString(), sysInfo.value("dev_name").toString());
Param idParam = Param(idParamTypesMap.value(info->thingClassId()), sysInfo.value("deviceId").toString());
descriptor.setParams(ParamList() << idParam);
Thing *existingThing = myThings().findByParams(ParamList() << idParam);
if (existingThing) {
descriptor.setThingId(existingThing->id());
}
// Sometimes kasa devices reply multiple times on the discovery call. Prevent duplicates in the search results.
bool found = false;
foreach (const ThingDescriptor &existingDescriptor, info->thingDescriptors()) {
if (existingDescriptor.params().paramValue(idParamTypesMap.value(info->thingClassId())) == idParam.value()) {
found = true;
break;
}
}
if (!found) {
info->addThingDescriptor(descriptor);
}
} else {
qCWarning(dcTplink()) << "Ignoring not matching device type:\n" << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented));
}
}
info->finish(Thing::ThingErrorNoError);
});
}
void IntegrationPluginTPLink::setupThing(ThingSetupInfo *info)
{
if (info->thing()->thingClassId() == kasaSocketThingClassId) {
qCDebug(dcTplink()) << "Setup thing for child socket:" << info->thing()->paramValue(kasaSocketThingIdParamTypeId).toString();
info->finish(Thing::ThingErrorNoError);
return;
}
QVariantMap map;
QVariantMap getSysInfo;
getSysInfo.insert("get_sysinfo", QVariant());
map.insert("system", getSysInfo);
QVariantMap getRealTime;
getRealTime.insert("get_realtime", QVariant());
map.insert("emeter", getRealTime);
QByteArray payload = QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact);
QByteArray datagram = encryptPayload(payload);
qint64 len = m_broadcastSocket->writeDatagram(datagram, QHostAddress::Broadcast, 9999);
if (len != datagram.length()) {
info->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("An error happened finding the device in the network."));
return;
}
QTimer::singleShot(2000, info, [this, info](){
while(m_broadcastSocket->hasPendingDatagrams()) {
char buffer[4096];
QHostAddress senderAddress;
qint64 len = m_broadcastSocket->readDatagram(buffer, 4096, &senderAddress);
QByteArray data = decryptPayload(QByteArray::fromRawData(buffer, len));
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcTplink()) << "Error parsing JSON from thing:" << data;
continue;
}
QVariantMap properties = jsonDoc.toVariant().toMap();
QVariantMap sysInfo = properties.value("system").toMap().value("get_sysinfo").toMap();
if (info->thing()->paramValue(idParamTypesMap.value(info->thing()->thingClassId())).toString() == sysInfo.value("deviceId").toString()) {
qCDebug(dcTplink()) << "Found thing at" << senderAddress;
// We need to finish the setup before we can generate childs for this thing
info->finish(Thing::ThingErrorNoError);
m_setupRetries.remove(info);
// Set up child sockets if needed (currently only the HS300)
QVariantList children = sysInfo.value("children").toList();
if (children.count() > 0 && myThings().filterByParentId(info->thing()->id()).isEmpty()) {
ThingDescriptors descriptors;
foreach (const QVariant &childVariant, children) {
QVariantMap childMap = childVariant.toMap();
ThingDescriptor descriptor(kasaSocketThingClassId, childMap.value("alias").toString(), QString(), info->thing()->id());
QString devId = QString("%1%2")
.arg(info->thing()->paramValue(idParamTypesMap.value(info->thing()->thingClassId())).toString())
.arg(childMap.value("id").toString());
descriptor.setParams(ParamList() << Param(kasaSocketThingIdParamTypeId, devId));
qCDebug(dcTplink()) << "Creating child socket for" << info->thing()->name() << "with ID" << devId;
descriptors.append(descriptor);
}
emit autoThingsAppeared(descriptors);
}
connectToDevice(info->thing(), senderAddress);
return;
}
}
if (!m_setupRetries.contains(info) || m_setupRetries.value(info) < 5) {
qCDebug(dcTplink()) << "Device not found in network. Retrying... (" << m_setupRetries[info] << ")";
m_setupRetries[info]++;
setupThing(info);
return;
}
m_setupRetries.remove(info);
info->finish(Thing::ThingErrorThingNotFound, QT_TR_NOOP("The device could not be found on the network."));
});
}
void IntegrationPluginTPLink::postSetupThing(Thing *thing)
{
qCDebug(dcTplink()) << "Post setup thing" << thing->name();
QTimer *jobTimer = new QTimer(thing);
jobTimer->setInterval(5000);
connect(jobTimer, &QTimer::timeout, thing, [this, thing](){
if (m_pendingJobs.contains(thing)) {
Job job = m_pendingJobs.take(thing);
qCWarning(dcTplink()) << "A job" << job.id << "timed out";
if (job.actionInfo) {
job.actionInfo->finish(Thing::ThingErrorTimeout);
}
processQueue(thing);
}
});
m_jobTimers[thing] = jobTimer;
connect(thing, &Thing::nameChanged, this, [this, thing](){
QVariantMap map;
QVariantMap systemMap;
QVariantMap aliasMap;
aliasMap.insert("alias", thing->name());
systemMap.insert("set_dev_alias", aliasMap);
map.insert("system", systemMap);
QByteArray payload = QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact);
qCDebug(dcTplink) << "Setting thing name:" << payload;
payload = encryptPayload(payload);
QByteArray data;
QDataStream stream(&data, QIODevice::ReadWrite);
stream << static_cast<quint32>(payload.length());
data.append(payload);
Job job;
job.id = m_jobIdx++;
job.data = data;
m_jobQueue[thing].append(job);
processQueue(thing);
});
if (!m_timer) {
m_timer = hardwareManager()->pluginTimerManager()->registerTimer(1);
connect(m_timer, &PluginTimer::timeout, this, [this](){
foreach (Thing *d, myThings()) {
if (d->parentId().isNull() && !m_pendingJobs.contains(d) && m_jobQueue[d].isEmpty()) {
fetchState(d);
}
}
});
}
// Update connected state in case the parent connected before we've completed the child setups
if (thing->thingClassId() == kasaSocketThingClassId) {
Thing *parent = myThings().findById(thing->parentId());
thing->setStateValue(kasaSocketConnectedStateTypeId, parent->stateValue(connectedStateTypesMap.value(parent->thingClassId())));
}
}
void IntegrationPluginTPLink::thingRemoved(Thing *thing)
{
qCDebug(dcTplink()) << "Device removed" << thing->name();
m_sockets.remove(thing);
m_pendingJobs.remove(thing);
m_jobQueue.remove(thing);
m_jobTimers.remove(thing);
if (myThings().isEmpty() && m_timer) {
hardwareManager()->pluginTimerManager()->unregisterTimer(m_timer);
m_timer = nullptr;
}
}
void IntegrationPluginTPLink::executeAction(ThingActionInfo *info)
{
// The actual thing to send the command to (either directly a physical thing or in case of a virtual socket the parent thing)
Thing *targetThing = info->thing()->parentId().isNull() ? info->thing() : myThings().findById(info->thing()->parentId());
QVariantMap powerMap;
powerMap.insert("state", info->action().param(info->action().actionTypeId()).value().toBool() ? 1 : 0);
QVariantMap systemMap;
systemMap.insert("set_relay_state", powerMap);
QVariantMap map;
map.insert("system", systemMap);
// If we're switching a virtual child, we need to add a context map for the child_ids
if (info->thing()->thingClassId() == kasaSocketThingClassId) {
QVariantMap contextMap;
contextMap.insert("child_ids", QVariantList() << info->thing()->paramValue(kasaSocketThingIdParamTypeId).toString());
map.insert("context", contextMap);
}
qCDebug(dcTplink()) << "Executing action" << qUtf8Printable(QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact));
QByteArray payload = encryptPayload(QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact));
QByteArray data;
QDataStream stream(&data, QIODevice::ReadWrite);
stream << static_cast<quint32>(payload.length());
data.append(payload);
Job job;
job.id = m_jobIdx++;
job.data = data;
job.actionInfo = info;
m_jobQueue[targetThing].append(job);
connect(info, &ThingActionInfo::aborted, targetThing, [this, targetThing, job](){
m_jobQueue[targetThing].removeAll(job);
});
// Directly queue up fetchState
fetchState(targetThing);
processQueue(targetThing);
}
QByteArray IntegrationPluginTPLink::encryptPayload(const QByteArray &payload)
{
QByteArray result;
int k = 171;
for (int i = 0; i < payload.length(); i++){
char t = payload.at(i) xor k;
k = t;
result.append(t);
}
return result;
}
QByteArray IntegrationPluginTPLink::decryptPayload(const QByteArray &payload)
{
QByteArray result;
int k = 171;
for (int i = 0; i < payload.length(); i++){
char t = payload.at(i);
result.append(t xor k);
k = t;
}
return result;
}
void IntegrationPluginTPLink::connectToDevice(Thing *thing, const QHostAddress &address)
{
if (m_sockets.contains(thing)) {
qCWarning(dcTplink) << "Already have a connection to this device";
return;
}
qCDebug(dcTplink()) << "Connecting to" << address;
QTcpSocket *socket = new QTcpSocket(this);
m_sockets.insert(thing, socket);
connect(socket, &QTcpSocket::connected, thing, [this, thing, address] () {
qCDebug(dcTplink()) << "Connected to device" << thing->name() << "at address:" << address;
StateTypeId connectedStateTypeId = connectedStateTypesMap.value(thing->thingClassId());
thing->setStateValue(connectedStateTypeId, true);
qCDebug(dcTplink()) << "Has childs:" << myThings().count();
foreach (Thing *child, myThings().filterByParentId(thing->id())) {
qCDebug(dcTplink()) << "Setting child online:" << child->paramValue(kasaSocketThingIdParamTypeId);
child->setStateValue(kasaSocketConnectedStateTypeId, true);
}
fetchState(thing);
});
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
connect(socket, &QTcpSocket::errorOccurred, this, [](QAbstractSocket::SocketError error){
#else
typedef void (QTcpSocket:: *errorSignal)(QAbstractSocket::SocketError);
connect(socket, static_cast<errorSignal>(&QTcpSocket::error), thing, [](QAbstractSocket::SocketError error) {
#endif
qCWarning(dcTplink()) << "Error in device connection:" << error;
});
connect(socket, &QTcpSocket::readyRead, thing, [this, socket, thing](){
m_inputBuffers[thing].append(socket->readAll());
while (m_inputBuffers[thing].length() > 4) {
QByteArray data = m_inputBuffers[thing];
QDataStream stream(data);
qint32 len;
stream >> len;
data.remove(0, 4);
if (data.length() < len) {
// Buffer not complete... wait for more...
return;
}
QByteArray payload = data.left(len);
data.remove(0, len);
m_inputBuffers[thing] = data;
if (!m_pendingJobs.contains(thing)) {
qCWarning(dcTplink()) << "Received packet from thing but don't have a job waiting for it. Did it time out?";
processQueue(thing);
return;
}
Job job = m_pendingJobs.take(thing);
m_jobTimers[thing]->stop();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(decryptPayload(payload), &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcTplink()) << "Cannot parse json from device:" << decryptPayload(payload);
m_jobQueue[thing].prepend(job);
socket->disconnectFromHost();
return;
}
qCDebug(dcTplink()) << "Socket data received" << qUtf8Printable(jsonDoc.toJson());
QVariantMap map = jsonDoc.toVariant().toMap();
if (map.contains("system")) {
QVariantMap systemMap = map.value("system").toMap();
if (systemMap.contains("set_relay_state")) {
int err_code = systemMap.value("set_relay_state").toMap().value("err_code").toInt();
if (err_code != 0) {
qCWarning(dcTplink()) << "Set relay state failed:" << qUtf8Printable(jsonDoc.toJson());
if (job.actionInfo) {
job.actionInfo->finish(Thing::ThingErrorHardwareFailure);
}
}
}
if (systemMap.contains("get_sysinfo")) {
StateTypeId signalStrengthStateTypeId = signalStrengthStateTypesMap.value(thing->thingClassId());
int rssi = systemMap.value("get_sysinfo").toMap().value("rssi").toInt();
int signalStrength = qMax(0, qMin(100, 2 * (rssi + 100)));
thing->setStateValue(signalStrengthStateTypeId, signalStrength);
if (thing->thingClassId() == kasaSocketThingClassId) {
foreach (Thing *child, myThings().filterByParentId(kasaSocketThingClassId)) {
child->setStateValue(kasaSocketSignalStrengthStateTypeId, signalStrength);
}
}
QString alias = systemMap.value("get_sysinfo").toMap().value("alias").toString();
if (thing->name() != alias) {
thing->setName(alias);
}
if (systemMap.value("get_sysinfo").toMap().contains("relay_state")) {
int relayState = systemMap.value("get_sysinfo").toMap().value("relay_state").toInt();
StateTypeId powerStateTypeId = powerStateTypesMap.value(thing->thingClassId());
thing->setStateValue(powerStateTypeId, relayState == 1 ? true : false);
} else if (systemMap.value("get_sysinfo").toMap().contains("children")) {
// For now, only the HS300 has children, which we map to child things of type kasaSocket
QVariantList children = systemMap.value("get_sysinfo").toMap().value("children").toList();
foreach (const QVariant &childVariant, children) {
QVariantMap childMap = childVariant.toMap();
QString idParam = childMap.value("id").toString();
bool relayState = childMap.value("state").toInt() == 1;
Things things = myThings().filterByParentId(thing->id()).filterByParam(kasaSocketThingIdParamTypeId, idParam);
if (things.count() == 1) {
things.first()->setStateValue(kasaSocketPowerStateTypeId, relayState);
} else {
qCWarning(dcTplink()) << "Error matching child devices" << qUtf8Printable(jsonDoc.toJson());
foreach (Thing *child, myThings().filterByParentId(thing->id())) {
qCDebug(dcTplink()) << "Existing child device:" << child->name() << child->params();
}
}
}
}
if (job.actionInfo) {
qCDebug(dcTplink()) << "Finishing action execution";
job.actionInfo->finish(Thing::ThingErrorNoError);
}
}
}
if (map.contains("emeter")) {
QVariantMap emeterMap = map.value("emeter").toMap();
if (emeterMap.contains("get_realtime")) {
// This has quite a bit of jitter... Let's smoothen it while within +/- 0.1W to produce less events in the system
StateTypeId currentPowerStateTypeId = currentPowerStatetTypesMap.value(thing->thingClassId());
double oldValue = thing->stateValue(currentPowerStateTypeId).toDouble();
double newValue = emeterMap.value("get_realtime").toMap().value("power_mw").toDouble() / 1000;
if (qAbs(oldValue - newValue) > 0.1) {
thing->setStateValue(currentPowerStateTypeId, newValue);
}
StateTypeId totalEnergyConsumedStateTypeId = totalEnergyConsumedStatetTypesMap.value(thing->thingClassId());
thing->setStateValue(totalEnergyConsumedStateTypeId, emeterMap.value("get_realtime").toMap().value("total_wh").toDouble() / 1000);
}
}
processQueue(thing);
}
});
connect(socket, &QTcpSocket::stateChanged, thing, [this, thing, address](QAbstractSocket::SocketState newState){
if (newState == QAbstractSocket::UnconnectedState) {
qCDebug(dcTplink()) << "Device disconnected";
m_sockets.take(thing)->deleteLater();
if (m_pendingJobs.contains(thing)) {
// Putting active job back to queue
m_jobQueue[thing].prepend(m_pendingJobs.take(thing));
}
StateTypeId connectedStateTypeId = connectedStateTypesMap.value(thing->thingClassId());
thing->setStateValue(connectedStateTypeId, false);
foreach (Thing *child, myThings().filterByParentId(thing->id())) {
child->setStateValue(kasaSocketConnectedStateTypeId, false);
}
QTimer::singleShot(500, thing, [this, thing, address]() {connectToDevice(thing, address);});
}
});
socket->connectToHost(address.toString(), 9999, QIODevice::ReadWrite);
}
void IntegrationPluginTPLink::fetchState(Thing *thing, ThingActionInfo *info)
{
QVariantMap map;
QVariantMap getSysInfo;
getSysInfo.insert("get_sysinfo", QVariant());
map.insert("system", getSysInfo);
QVariantMap getRealTime;
getRealTime.insert("get_realtime", QVariant());
map.insert("emeter", getRealTime);
QByteArray plaintext = QJsonDocument::fromVariant(map).toJson(QJsonDocument::Compact);
qCDebug(dcTplink()) << "Fetching device state";
QByteArray payload = encryptPayload(plaintext);
QByteArray data;
QDataStream stream(&data, QIODevice::ReadWrite);
stream << static_cast<quint32>(payload.length());
data.append(payload);
Job job;
job.id = m_jobIdx++;
job.data = data;
job.actionInfo = info;
m_jobQueue[thing].append(job);
processQueue(thing);
}
void IntegrationPluginTPLink::processQueue(Thing *thing)
{
if (m_pendingJobs.contains(thing)) {
qCDebug(dcTplink()) << "Already processing a message to" << thing->name();
// Busy
return;
}
if (m_jobQueue[thing].isEmpty()) {
// No jobs queued for this thing
return;
}
QTcpSocket *socket = m_sockets.value(thing);
if (!socket) {
qCWarning(dcTplink()) << "Cannot process queue. Device not connected.";
return;
}
Job job = m_jobQueue[thing].takeFirst();
m_pendingJobs[thing] = job;
qint64 len = socket->write(job.data);
if (len != job.data.length()) {
qCWarning(dcTplink()) << "Error writing data to network.";
if (job.actionInfo) {
job.actionInfo->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("Error sending command to the network."));
}
socket->disconnectFromHost();
return;
}
m_jobTimers[thing]->start();
}
Reference in New Issue View Git Blame Copy Permalink