mirror of
https://github.com/nymea/nymea-plugins.git
synced 2026-07-17 00:36:35 +02:00
550 lines
26 KiB
C++
550 lines
26 KiB
C++
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* Copyright 2013 - 2020, nymea GmbH
|
|
* Contact: contact@nymea.io
|
|
*
|
|
* This file is part of nymea.
|
|
* This project including source code and documentation is protected by
|
|
* copyright law, and remains the property of nymea GmbH. All rights, including
|
|
* reproduction, publication, editing and translation, are reserved. The use of
|
|
* this project is subject to the terms of a license agreement to be concluded
|
|
* with nymea GmbH in accordance with the terms of use of nymea GmbH, available
|
|
* under https://nymea.io/license
|
|
*
|
|
* GNU Lesser General Public License Usage
|
|
* Alternatively, this project may be redistributed and/or modified under the
|
|
* terms of the GNU Lesser General Public License as published by the Free
|
|
* Software Foundation; version 3. This project 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this project. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* For any further details and any questions please contact us under
|
|
* contact@nymea.io or see our FAQ/Licensing Information on
|
|
* https://nymea.io/license/faq
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "integrationpluginmiele.h"
|
|
#include "plugininfo.h"
|
|
#include <cmath>
|
|
|
|
#include <QJsonDocument>
|
|
#include <QUrl>
|
|
#include <QUrlQuery>
|
|
|
|
IntegrationPluginMiele::IntegrationPluginMiele()
|
|
{
|
|
m_idParamTypeIds.insert(ovenThingClassId, ovenThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(fridgeThingClassId, fridgeThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(dryerThingClassId, dryerThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(coffeeMakerThingClassId, coffeeMakerThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(dishwasherThingClassId, dishwasherThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(washerThingClassId, washerThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(cookTopThingClassId, cookTopThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(hoodThingClassId, hoodThingIdParamTypeId);
|
|
m_idParamTypeIds.insert(cleaningRobotThingClassId, cleaningRobotThingIdParamTypeId);
|
|
|
|
m_connectedStateTypeIds.insert(ovenThingClassId, ovenConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(fridgeThingClassId, fridgeConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(dryerThingClassId, dryerConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(coffeeMakerThingClassId, coffeeMakerConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(dishwasherThingClassId, dishwasherConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(washerThingClassId, washerConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(cookTopThingClassId, cookTopConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(cleaningRobotThingClassId, cleaningRobotConnectedStateTypeId);
|
|
m_connectedStateTypeIds.insert(hoodThingClassId, hoodConnectedStateTypeId);
|
|
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("oven", ovenThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("washing machine", washerThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("dish washer", dishwasherThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("coffee system", coffeeMakerThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("tumber dryer", dryerThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("refrigerator", fridgeThingClassId);
|
|
m_mieleDeviceTypeLabelToThingClassId.insert("hood", hoodThingClassId);
|
|
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::Oven, ovenThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::WashingMachine, washerThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::DishWasher, dishwasherThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::CoffeeSystem, coffeeMakerThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::TumbleDryer, dryerThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::Fridge, fridgeThingClassId);
|
|
m_mieleDeviceTypeToThingClassId.insert(Miele::DeviceType::Hood, hoodThingClassId);
|
|
|
|
}
|
|
|
|
void IntegrationPluginMiele::startPairing(ThingPairingInfo *info)
|
|
{
|
|
if (info->thingClassId() == mieleAccountThingClassId) {
|
|
qCDebug(dcMiele()) << "Start pairing Miele account";
|
|
Miele *miele = createMieleConnection();
|
|
if (!miele) {
|
|
info->finish(Thing::ThingErrorAuthenticationFailure);
|
|
return;
|
|
}
|
|
QUrl url = miele->getLoginUrl(QUrl("https://127.0.0.1:8888"));
|
|
m_setupMieleConnections.insert(info->thingId(), miele);
|
|
info->setOAuthUrl(url);
|
|
info->finish(Thing::ThingErrorNoError);
|
|
} else {
|
|
qCWarning(dcMiele()) << "Unhandled pairing metod!";
|
|
info->finish(Thing::ThingErrorCreationMethodNotSupported);
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::confirmPairing(ThingPairingInfo *info, const QString &username, const QString &secret)
|
|
{
|
|
//Q_UNUSED(username);
|
|
|
|
qCDebug(dcMiele()) << "\n\n Confirm pairing for username: [" << username << "]";
|
|
|
|
if (info->thingClassId() == mieleAccountThingClassId) {
|
|
qCDebug(dcMiele()) << "Confirm pairing Miele account";
|
|
QUrl url(secret);
|
|
QUrlQuery query(url);
|
|
QByteArray authorizationCode = query.queryItemValue("code").toLocal8Bit();
|
|
|
|
Miele *miele = m_setupMieleConnections.value(info->thingId());
|
|
if (!miele) {
|
|
qWarning(dcMiele()) << "No Miele connection found for thing:" << info->thingName();
|
|
m_setupMieleConnections.remove(info->thingId());
|
|
info->finish(Thing::ThingErrorAuthenticationFailure);
|
|
return;
|
|
}
|
|
qCDebug(dcMiele()) << "Authorization code" << authorizationCode;
|
|
miele->getAccessTokenFromAuthorizationCode(authorizationCode);
|
|
connect(info, &ThingPairingInfo::aborted, miele, &Miele::deleteLater);
|
|
connect(miele, &Miele::receivedRefreshToken, info, [info, this](const QByteArray &refreshToken){
|
|
qCDebug(dcMiele()) << "Token:" << refreshToken;
|
|
|
|
pluginStorage()->beginGroup(info->thingId().toString());
|
|
pluginStorage()->setValue("refresh_token", refreshToken);
|
|
pluginStorage()->endGroup();
|
|
|
|
info->finish(Thing::ThingErrorNoError);
|
|
});
|
|
} else {
|
|
Q_ASSERT_X(false, "confirmPairing", QString("Unhandled thingClassId: %1").arg(info->thingClassId().toString()).toUtf8());
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::setupThing(ThingSetupInfo *info)
|
|
{
|
|
Thing *thing = info->thing();
|
|
|
|
if (thing->thingClassId() == mieleAccountThingClassId) {
|
|
qCDebug(dcMiele()) << "Setup Miele Account";
|
|
Miele *miele;
|
|
|
|
if (m_mieleConnections.contains(thing)) {
|
|
qCDebug(dcMiele()) << "Setup after reconfiguration, cleaning up";
|
|
m_mieleConnections.take(thing)->deleteLater();
|
|
}
|
|
|
|
if (m_setupMieleConnections.keys().contains(thing->id())) {
|
|
//Fresh device setup, has already a fresh access token
|
|
qCDebug(dcMiele()) << "Miele OAuth setup complete";
|
|
miele = m_setupMieleConnections.take(thing->id());
|
|
m_mieleConnections.insert(thing, miele);
|
|
info->finish(Thing::ThingErrorNoError);
|
|
} else {
|
|
// device loaded from the device database, needs a new access token;
|
|
pluginStorage()->beginGroup(thing->id().toString());
|
|
QByteArray refreshToken = pluginStorage()->value("refresh_token").toByteArray();
|
|
pluginStorage()->endGroup();
|
|
if (refreshToken.isEmpty()) {
|
|
info->finish(Thing::ThingErrorAuthenticationFailure, tr("Refresh token is not available."));
|
|
return;
|
|
}
|
|
miele = createMieleConnection();
|
|
if (!miele) {
|
|
return info->finish(Thing::ThingErrorSetupFailed);
|
|
}
|
|
miele->getAccessTokenFromRefreshToken(refreshToken);
|
|
connect(miele, &Miele::receivedAccessToken, info, [this, info, miele] {
|
|
m_mieleConnections.insert(info->thing(), miele);
|
|
info->finish(Thing::ThingErrorNoError);
|
|
});
|
|
connect(miele, &Miele::receivedRefreshToken, info, [info, thing, this](const QByteArray &refreshToken){
|
|
pluginStorage()->beginGroup(thing->id().toString());
|
|
pluginStorage()->setValue("refresh_token", refreshToken);
|
|
pluginStorage()->endGroup();
|
|
info->finish(Thing::ThingErrorNoError);
|
|
});
|
|
connect(info, &ThingSetupInfo::aborted, miele, &Miele::deleteLater);
|
|
connect(miele, &Miele::devicesFound, this, &IntegrationPluginMiele::onDevicesFound);
|
|
connect(miele, &Miele::deviceStateReceived, this, &IntegrationPluginMiele::onDeviceStateReceived);
|
|
connect(miele, &Miele::deviceNotFound, this, &IntegrationPluginMiele::onDeviceNotFound);
|
|
}
|
|
} else if (m_idParamTypeIds.contains(thing->thingClassId())) {
|
|
Thing *parentThing = myThings().findById(thing->parentId());
|
|
if (parentThing->setupComplete()) {
|
|
info->finish(Thing::ThingErrorNoError);
|
|
} else {
|
|
connect(parentThing, &Thing::setupStatusChanged, info, [parentThing, info]{
|
|
if (parentThing->setupComplete()) {
|
|
info->finish(Thing::ThingErrorNoError);
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
Q_ASSERT_X(false, "setupThing", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
|
|
}
|
|
|
|
}
|
|
|
|
void IntegrationPluginMiele::postSetupThing(Thing *thing)
|
|
{
|
|
qCDebug(dcMiele()) << "Post setup thing" << thing->name();
|
|
if (!m_pluginTimer15min) {
|
|
qCDebug(dcMiele()) << "Registering plugin timer";
|
|
m_pluginTimer15min = hardwareManager()->pluginTimerManager()->registerTimer(60 * 1);
|
|
connect(m_pluginTimer15min, &PluginTimer::timeout, this, [this]() {
|
|
qCDebug(dcMiele()) << "Plugin timer triggered";
|
|
Q_FOREACH (Thing *thing, myThings().filterByThingClassId(mieleAccountThingClassId)) {
|
|
Miele *miele = m_mieleConnections.value(thing);
|
|
if (!miele) {
|
|
qWarning(dcMiele()) << "No Miele account found for" << thing->name();
|
|
continue;
|
|
}
|
|
miele->getDevices();
|
|
Q_FOREACH (Thing *childThing, myThings().filterByParentId(thing->id())) {
|
|
QString deviceId = childThing->paramValue(m_idParamTypeIds.value(childThing->thingClassId())).toString();
|
|
miele->getDeviceState(deviceId);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (thing->thingClassId() == mieleAccountThingClassId) {
|
|
Miele *miele = m_mieleConnections.value(thing);
|
|
miele->getDevices();
|
|
miele->connectEventStream();
|
|
thing->setStateValue(mieleAccountConnectedStateTypeId, true);
|
|
thing->setStateValue(mieleAccountLoggedInStateTypeId, true);
|
|
} else if (m_idParamTypeIds.contains(thing->thingClassId())) {
|
|
Thing *parentThing = myThings().findById(thing->parentId());
|
|
if (!parentThing)
|
|
qCWarning(dcMiele()) << "Could not find parent with Id" << thing->parentId().toString();
|
|
Miele *miele = m_mieleConnections.value(parentThing);
|
|
QString deviceId = thing->paramValue(m_idParamTypeIds.value(thing->thingClassId())).toString();
|
|
if (!miele) {
|
|
qCWarning(dcMiele()) << "Could not find HomeConnect connection for thing" << thing->name();
|
|
} else {
|
|
miele->getDeviceState(deviceId);
|
|
}
|
|
} else {
|
|
Q_ASSERT_X(false, "postSetupThing", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::executeAction(ThingActionInfo *info)
|
|
{
|
|
Thing *thing = info->thing();
|
|
Action action = info->action();
|
|
Miele *miele = m_mieleConnections.value(myThings().findById(thing->parentId()));
|
|
if (!miele) {
|
|
return info->finish(Thing::ThingErrorHardwareNotAvailable);
|
|
}
|
|
QString deviceId = thing->paramValue(m_idParamTypeIds.value(thing->thingClassId())).toString();
|
|
|
|
if (thing->thingClassId() == fridgeThingClassId) {
|
|
if (action.actionTypeId() == fridgeTargetTemperatureActionTypeId) {
|
|
double targetTemp = action.param(fridgeTargetTemperatureActionTargetTemperatureParamTypeId).value().toDouble();
|
|
int iTargetTemp = floor(targetTemp);
|
|
qCDebug(dcMiele()) << "Setting fridge temp: " << iTargetTemp;
|
|
QUuid requestId = miele->setTargetTemperature(deviceId, 1, iTargetTemp);
|
|
info->finish(Thing::ThingErrorNoError);
|
|
thing->setStateValue(fridgeTargetTemperatureStateTypeId, iTargetTemp);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
} else if (action.actionTypeId() == fridgeStartSuperCoolingActionTypeId) {
|
|
QUuid requestId = miele->processAction(deviceId, Miele::ProcessActionsStartSupercooling);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
// don't set state, it should come as event once it successfully started on the actual device
|
|
//thing->setStateValue(fridgePowerStateTypeId, !currentSuperCoolingState);
|
|
} else if (action.actionTypeId() == fridgeStopSuperCoolingActionTypeId) {
|
|
QUuid requestId = miele->processAction(deviceId, Miele::ProcessActionsStopSupercooling);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
}
|
|
} else if (thing->thingClassId() == hoodThingClassId) {
|
|
if (action.actionTypeId() == hoodStopHoodActionTypeId) {
|
|
// TODO: should check if current state of the hood allows the Stop action
|
|
QUuid requestId = miele->processAction(deviceId, Miele::ProcessActionsStop);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
} else if (action.actionTypeId() == hoodVentilationStepActionTypeId) {
|
|
int ventStep = action.param(hoodVentilationStepActionVentilationStepParamTypeId).value().toInt();
|
|
QUuid requestId = miele->setVentilationStep(deviceId, ventStep);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
} else if (action.actionTypeId() == hoodLightColorActionTypeId) {
|
|
QString color = action.param(hoodLightColorActionLightColorParamTypeId).value().toString();
|
|
QUuid requestId = miele->setColorsStr(deviceId, color);
|
|
m_pendingActions.insert(requestId, info);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
} else if (action.actionTypeId() == hoodLightActionTypeId) {
|
|
bool power = action.param(hoodLightActionLightParamTypeId).value().toBool();
|
|
QUuid requestId = miele->setLight(deviceId, power);
|
|
connect(info, &ThingActionInfo::aborted, [requestId, this] {
|
|
m_pendingActions.remove(requestId);
|
|
});
|
|
}
|
|
|
|
} else if (thing->thingClassId() == ovenThingClassId) {
|
|
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::thingRemoved(Thing *thing)
|
|
{
|
|
qCDebug(dcMiele) << "Delete " << thing->name();
|
|
|
|
if (thing->thingClassId() == mieleAccountThingClassId) {
|
|
m_mieleConnections.take(thing)->deleteLater();
|
|
}
|
|
|
|
if (myThings().empty()) {
|
|
if (m_pluginTimer15min) {
|
|
hardwareManager()->pluginTimerManager()->unregisterTimer(m_pluginTimer15min);
|
|
m_pluginTimer15min = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
Miele *IntegrationPluginMiele::createMieleConnection()
|
|
{
|
|
QByteArray clientId = configValue(mielePluginCustomClientIdParamTypeId).toByteArray();
|
|
QByteArray clientSecret = configValue(mielePluginCustomClientSecretParamTypeId).toByteArray();
|
|
if (clientId.isEmpty() || clientSecret.isEmpty()) {
|
|
clientId = apiKeyStorage()->requestKey("miele").data("clientId");
|
|
clientSecret = apiKeyStorage()->requestKey("miele").data("clientSecret");
|
|
|
|
if (clientId.isEmpty() || clientSecret.isEmpty()) {
|
|
qCWarning(dcMiele()) << "No API credentials available, cannot create Miele connection";
|
|
return nullptr;
|
|
} else {
|
|
qCDebug(dcMiele()) << "Using api credentials from API key provider";
|
|
}
|
|
} else {
|
|
qCDebug(dcMiele()) << "Using custom api credentials";
|
|
}
|
|
Miele *miele = new Miele(hardwareManager()->networkManager(), clientId, clientSecret, "en", this);
|
|
connect(miele, &Miele::destroyed, this, [this, miele] {
|
|
m_setupMieleConnections.remove(m_setupMieleConnections.key(miele));
|
|
m_mieleConnections.remove(m_mieleConnections.key(miele));
|
|
});
|
|
return miele;
|
|
}
|
|
|
|
void IntegrationPluginMiele::onConnectionChanged(bool connected)
|
|
{
|
|
Miele *miele = static_cast<Miele *>(sender());
|
|
Thing *thing = m_mieleConnections.key(miele);
|
|
if (!thing)
|
|
return;
|
|
thing->setStateValue(mieleAccountConnectedStateTypeId, connected);
|
|
if (!connected) {
|
|
Q_FOREACH(Thing *child, myThings().filterByParentId(thing->id())) {
|
|
child->setStateValue(m_connectedStateTypeIds.value(child->thingClassId()), connected);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::onAuthenticationStatusChanged(bool authenticated)
|
|
{
|
|
Miele *mieleConnection = static_cast<Miele *>(sender());
|
|
if (m_asyncSetup.contains(mieleConnection)) {
|
|
ThingSetupInfo *info = m_asyncSetup.take(mieleConnection);
|
|
if (authenticated) {
|
|
m_mieleConnections.insert(info->thing(), mieleConnection);
|
|
info->finish(Thing::ThingErrorNoError);
|
|
} else {
|
|
mieleConnection->deleteLater();
|
|
info->finish(Thing::ThingErrorHardwareFailure);
|
|
}
|
|
} else {
|
|
Thing *thing = m_mieleConnections.key(mieleConnection);
|
|
if (!thing)
|
|
return;
|
|
|
|
thing->setStateValue(mieleAccountLoggedInStateTypeId, authenticated);
|
|
if (!authenticated) {
|
|
//refresh access token needs to be refreshed
|
|
pluginStorage()->beginGroup(thing->id().toString());
|
|
QByteArray refreshToken = pluginStorage()->value("refresh_token").toByteArray();
|
|
pluginStorage()->endGroup();
|
|
mieleConnection->getAccessTokenFromRefreshToken(refreshToken);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::onRequestExecuted(QUuid requestId, bool success)
|
|
{
|
|
if (m_pendingActions.contains(requestId)) {
|
|
ThingActionInfo *info = m_pendingActions.value(requestId);
|
|
if (success) {
|
|
info->finish(Thing::ThingErrorNoError);
|
|
} else {
|
|
info->finish(Thing::ThingErrorHardwareNotAvailable);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::onDevicesFound(QList<Miele::DeviceShort> devices)
|
|
{
|
|
qCDebug(dcMiele()) << "Found " << devices.size() << " devices";
|
|
Miele *miele = static_cast<Miele*>(sender());
|
|
|
|
if(m_mieleConnections.values().contains(miele)) {
|
|
Thing *parentDevice = myThings().findById(m_mieleConnections.key(miele)->id());
|
|
qCDebug(dcMiele()) << devices.size() << " devices received for parent: " << parentDevice->id();
|
|
|
|
ThingDescriptors descriptors;
|
|
foreach(Miele::DeviceShort ds, devices) {
|
|
qCDebug(dcMiele()) << "Setting up device: " << ds.type << " " << ds.name;
|
|
if (!m_mieleDeviceTypeToThingClassId.contains(ds.type)) {
|
|
qCDebug(dcMiele()) << "Device type [" << ds.type << "] is not supported!";
|
|
continue;
|
|
}
|
|
ThingClassId deviceClassId = m_mieleDeviceTypeToThingClassId.value(ds.type);
|
|
ThingDescriptor descriptor(deviceClassId, ds.name, "Appliance type: " + ds.type, parentDevice->id());
|
|
ParamList params;
|
|
params.append(Param(m_idParamTypeIds.value(deviceClassId), ds.fabNumber));
|
|
if (myThings().findByParams(params)) {
|
|
continue;
|
|
}
|
|
descriptor.setParams(params);
|
|
descriptors.append(descriptor);
|
|
}
|
|
emit autoThingsAppeared(descriptors);
|
|
|
|
} else {
|
|
// TODO: improve debug message
|
|
qCWarning(dcMiele()) << "Miele connection not linked to a thingId";
|
|
}
|
|
}
|
|
|
|
|
|
void IntegrationPluginMiele::onDeviceStateReceived(const QString &deviceId, const QVariantMap &deviceState)
|
|
{
|
|
Miele *miele = static_cast<Miele*>(sender());
|
|
if (!m_mieleConnections.values().contains(miele)) {
|
|
qCWarning(dcMiele()) << "Can't find Miele connection!";
|
|
return;
|
|
}
|
|
|
|
Thing *parentDevice = myThings().findById(m_mieleConnections.key(miele)->id());
|
|
if (!parentDevice) {
|
|
qCWarning(dcMiele()) << "Can't find parent thing!";
|
|
return;
|
|
}
|
|
|
|
foreach(Thing *thing, myThings().filterByParentId(parentDevice->id())) {
|
|
if (thing->paramValue(m_idParamTypeIds.value(thing->thingClassId())).toString() == deviceId) {
|
|
qCDebug(dcMiele()) << "Received state for: " << thing->name();
|
|
setThingState(thing, deviceState);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void IntegrationPluginMiele::setThingState(Thing *thing, const QVariantMap &state)
|
|
{
|
|
qCDebug(dcMiele()) << "Setting device state: " << thing->name();
|
|
if (thing->thingClassId() == fridgeThingClassId) {
|
|
qCDebug(dcMiele()) << "Setting state for fridge!";
|
|
|
|
bool connected = state.value("status").toMap().value("value_raw").toInt() == Miele::StatusNotConnected
|
|
? false
|
|
: true;
|
|
thing->setStateValue(m_connectedStateTypeIds.value(thing->thingClassId()), connected);
|
|
thing->setStateValue(fridgeOperationStateStateTypeId, state.value("status").toMap().value("value_localized").toString());
|
|
|
|
// Fridges should have only one temperature zone
|
|
QVariant fridgeTempZone = state.value("temperature").toList().first();
|
|
double fridgeTemp = fridgeTempZone.toMap().value("value_raw").toDouble();
|
|
thing->setStateValue(fridgeTemperatureStateTypeId, fridgeTemp / 100);
|
|
|
|
QVariant fridgeTargetTempZone = state.value("targetTemperature").toList().first();
|
|
double fridgeTargetTemp = fridgeTargetTempZone.toMap().value("value_raw").toDouble();
|
|
thing->setStateValue(fridgeTargetTemperatureStateTypeId, fridgeTargetTemp / 100);
|
|
|
|
thing->setStateValue(fridgeSignalDoorStateTypeId, state.value("signalDoor").toBool());
|
|
thing->setStateValue(fridgeSignalInfoStateTypeId, state.value("signalInfo").toBool());
|
|
thing->setStateValue(fridgeSignalFailureStateTypeId, state.value("signalFailure").toBool());
|
|
|
|
QVariantMap remoteEnabledModes = state.value("remoteEnable").toMap();
|
|
thing->setStateValue(fridgeFullRemoteControlStateTypeId, remoteEnabledModes.value("fullRemoteControl").toBool());
|
|
thing->setStateValue(fridgeSmartGridStateTypeId, remoteEnabledModes.value("smartGrid").toBool());
|
|
thing->setStateValue(fridgeMobileStartStateTypeId, remoteEnabledModes.value("mobileStart").toBool());
|
|
|
|
} else if (thing->thingClassId() == hoodThingClassId) {
|
|
qCDebug(dcMiele()) << "Setting state for hood!";
|
|
|
|
int status = state.value("status").toMap().value("value_raw").toInt();
|
|
bool connected = (status == Miele::StatusNotConnected) ? false : true;
|
|
bool poweredOn = (status == Miele::StatusOff) ? false : true;
|
|
thing->setStateValue(m_connectedStateTypeIds.value(thing->thingClassId()), connected);
|
|
thing->setStateValue(hoodPowerStateTypeId, poweredOn);
|
|
thing->setStateValue(hoodOperationStateStateTypeId, state.value("status").toMap().value("value_localized").toString());
|
|
|
|
thing->setStateValue(hoodSignalInfoStateTypeId, state.value("signalInfo").toBool());
|
|
thing->setStateValue(hoodSignalFailureStateTypeId, state.value("signalFailure").toBool());
|
|
thing->setStateValue(hoodLightStateTypeId, state.value("light").toInt() != 0 ? true : false);
|
|
|
|
QVariantMap remoteEnabledModes = state.value("remoteEnable").toMap();
|
|
thing->setStateValue(hoodFullRemoteControlStateTypeId, remoteEnabledModes.value("fullRemoteControl").toBool());
|
|
thing->setStateValue(hoodSmartGridStateTypeId, remoteEnabledModes.value("smartGrid").toBool());
|
|
thing->setStateValue(hoodMobileStartStateTypeId, remoteEnabledModes.value("mobileStart").toBool());
|
|
|
|
int ventilationStep = state.value("ventilationStep").toMap().value("value_raw").toInt();
|
|
thing->setStateValue(hoodVentilationStepStateTypeId, ventilationStep);
|
|
} else {
|
|
qCWarning(dcMiele()) << "Device " << thing->name() << " is not yet supported!";
|
|
}
|
|
}
|
|
|
|
void IntegrationPluginMiele::onDeviceNotFound(const QString &deviceId)
|
|
{
|
|
Miele *miele = static_cast<Miele*>(sender());
|
|
if (!m_mieleConnections.values().contains(miele)) {
|
|
qCWarning(dcMiele()) << "Can't find Miele connection!";
|
|
return;
|
|
}
|
|
|
|
Thing *parentDevice = myThings().findById(m_mieleConnections.key(miele)->id());
|
|
if (!parentDevice) {
|
|
qCWarning(dcMiele()) << "Can't find parent thing!";
|
|
return;
|
|
}
|
|
|
|
foreach(Thing *thing, myThings().filterByParentId(parentDevice->id())) {
|
|
if (thing->paramValue(m_idParamTypeIds.value(thing->thingClassId())).toString() == deviceId) {
|
|
qCDebug(dcMiele()) << "Device not found anymore: " << thing->name();
|
|
emit autoThingDisappeared(thing->id());
|
|
break;
|
|
}
|
|
}
|
|
}
|