mirror of https://github.com/nymea/nymea.git
426 lines
16 KiB
C++
426 lines
16 KiB
C++
/****************************************************************************
|
|
* *
|
|
* This file is part of guh. *
|
|
* *
|
|
* Guh 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, version 2 of the License. *
|
|
* *
|
|
* Guh 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 guh. If not, see <http://www.gnu.org/licenses/>. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
/*!
|
|
\page openweathermap.html
|
|
\title Open Weather Map
|
|
|
|
\ingroup plugins
|
|
\ingroup services
|
|
|
|
This plugin gives the possibility to get weather data...
|
|
|
|
\chapter Plugin propertys:
|
|
\section1 Actions
|
|
Following list contains all plugin \l{Action}s:
|
|
\table
|
|
\header
|
|
\li Name
|
|
\li Description
|
|
\li UUID
|
|
\row
|
|
\li refresh
|
|
\li This action refreshes all states. Only, if a state value realy changed
|
|
a notification get emited.
|
|
\li cfbc6504-d86f-4856-8dfa-97b6fbb385e4
|
|
\endtable
|
|
\section1 Events:
|
|
Following list contains all plugin \l{Event}s:
|
|
\table
|
|
\header
|
|
\li Name
|
|
\li UUID
|
|
\li Description
|
|
\row
|
|
\li
|
|
\li
|
|
\li
|
|
\endtable
|
|
\section1 States
|
|
Following list contains all plugin \l{State}s:
|
|
\table
|
|
\header
|
|
\li Name
|
|
\li Description
|
|
\li UUID
|
|
\li Data Type
|
|
\row
|
|
\li city name
|
|
\li The name of the city
|
|
\li fd9e7b7f-cf1f-4093-8f6d-fff5b223471f
|
|
\li string
|
|
\row
|
|
\li city id
|
|
\li The city ID for openweathermap.org
|
|
\li c6ef1c07-e817-4251-b83d-115bbf6f0ae9
|
|
\li string
|
|
\row
|
|
\li country name
|
|
\li The country name
|
|
\li 0e607a5f-1938-4e77-a146-15e9ad15bfad
|
|
\li string
|
|
\row
|
|
\li last update
|
|
\li The timestamp of the weather data from the weatherstation in unixtime
|
|
format
|
|
\li 98e48095-87da-47a4-b812-28c6c17a3e76
|
|
\li unsignend int
|
|
\row
|
|
\li temperature
|
|
\li Current temperature [Celsius]
|
|
\li 2f949fa3-ff21-4721-87ec-0a5c9d0a5b8a
|
|
\li double
|
|
\row
|
|
\li temperature minimum
|
|
\li Today temperature minimum [Clesius]
|
|
\li 701338b3-80de-4c95-8abf-26f44529d620
|
|
\li double
|
|
\row
|
|
\li temperature maximum
|
|
\li Today temperature maximum [Clesius]
|
|
\li f69bedd2-c997-4a7d-9242-76bf2aab3d3d
|
|
\li double
|
|
\row
|
|
\li humidity
|
|
\li Current relative humidity [%]
|
|
\li 3f01c9f0-206b-4477-afa2-80d6e5e54fbb
|
|
\li int
|
|
\row
|
|
\li pressure
|
|
\li Current pressure [hPa]
|
|
\li 6a57b6e9-7010-4a89-982c-ce0bc2a71f11
|
|
\li double
|
|
\row
|
|
\li wind speed
|
|
\li Current wind speed [m/s]
|
|
\li 12dc85a9-825d-4375-bef4-abd66e9e301b
|
|
\li double
|
|
\row
|
|
\li wind direction
|
|
\li The wind direction rellative to the north pole [degree]
|
|
\li a8b0383c-d615-41fe-82b8-9b797f045cc9
|
|
\li int
|
|
\row
|
|
\li cloudiness
|
|
\li This value represents how much of the sky is clowdy [%]
|
|
\li 0c1dc881-560e-40ac-a4a1-9ab69138cfe3
|
|
\li int
|
|
\row
|
|
\li weather description
|
|
\li This string describes the current weather condition in clear words
|
|
\li e71d98e3-ebd8-4abf-ad25-9ecc2d05276a
|
|
\li string
|
|
\row
|
|
\li sunset
|
|
\li The time of todays sunset in unixtime format
|
|
\li 5dd6f5a3-25d6-4e60-82ca-e934ad76a4b6
|
|
\li unsigned int
|
|
\row
|
|
\li sunrise
|
|
\li The time of todays sunrise in unixtime format
|
|
\li 413b3fc6-bd1c-46fb-8c86-03096254f94f
|
|
\li unsigned int
|
|
\endtable
|
|
*/
|
|
|
|
|
|
#include "devicepluginopenweathermap.h"
|
|
|
|
#include "plugin/device.h"
|
|
#include "devicemanager.h"
|
|
|
|
#include <QDebug>
|
|
#include <QJsonDocument>
|
|
#include <QVariantMap>
|
|
#include <QDateTime>
|
|
|
|
VendorId openweathermapVendorId = VendorId("bf1e96f0-9650-4e7c-a56c-916d54d18e7a");
|
|
DeviceClassId openweathermapDeviceClassId = DeviceClassId("985195aa-17ad-4530-88a4-cdd753d747d7");
|
|
|
|
ActionTypeId updateWeatherActionTypeId = ActionTypeId("cfbc6504-d86f-4856-8dfa-97b6fbb385e4");
|
|
|
|
StateTypeId updateTimeStateTypeId = StateTypeId("36b2f09b-7d77-4fbc-a68f-23d735dda0b1");
|
|
StateTypeId temperatureStateTypeId = StateTypeId("6013402f-b5b1-46b3-8490-f0c20d62fe61");
|
|
StateTypeId temperatureMinStateTypeId = StateTypeId("14ec2781-cb04-4bbf-b097-7d01ef982630");
|
|
StateTypeId temperatureMaxStateTypeId = StateTypeId("fefe5563-452f-4833-b5cf-49c3cc67c772");
|
|
StateTypeId humidityStateTypeId = StateTypeId("6f32ec73-3240-4630-ada9-1c10b8e98123");
|
|
StateTypeId pressureStateTypeId = StateTypeId("4a42eea9-00eb-440b-915e-dbe42180f83b");
|
|
StateTypeId windSpeedStateTypeId = StateTypeId("2bf63430-e9e2-4fbf-88e6-6f1b4770f287");
|
|
StateTypeId windDirectionStateTypeId = StateTypeId("589e2ea5-65b2-4afd-9b72-e3708a589a12");
|
|
StateTypeId cloudinessStateTypeId = StateTypeId("798553bc-45c7-42eb-9105-430bddb5d9b7");
|
|
StateTypeId weatherDescriptionStateTypeId = StateTypeId("f9539108-0e0e-4736-a306-6408f8e20a26");
|
|
StateTypeId sunriseStateTypeId = StateTypeId("af155e94-9492-44e1-8608-7d0ee8b5d50d");
|
|
StateTypeId sunsetStateTypeId = StateTypeId("a1dddc3d-549f-4f20-b78b-be850548f286");
|
|
|
|
|
|
DevicePluginOpenweathermap::DevicePluginOpenweathermap()
|
|
{
|
|
m_openweaher = new OpenWeatherMap(this);
|
|
connect(m_openweaher, SIGNAL(searchResultReady(QList<QVariantMap>)), this, SLOT(searchResultsReady(QList<QVariantMap>)));
|
|
connect(m_openweaher, SIGNAL(weatherDataReady(QByteArray)), this, SLOT(weatherDataReady(QByteArray)));
|
|
}
|
|
|
|
QList<Vendor> DevicePluginOpenweathermap::supportedVendors() const
|
|
{
|
|
QList<Vendor> ret;
|
|
Vendor openweathermap(openweathermapVendorId, "openweathermap");
|
|
ret.append(openweathermap);
|
|
return ret;
|
|
}
|
|
|
|
QList<DeviceClass> DevicePluginOpenweathermap::supportedDevices() const
|
|
{
|
|
QList<DeviceClass> ret;
|
|
|
|
DeviceClass deviceClassOpenweathermap(pluginId(), openweathermapVendorId, openweathermapDeviceClassId);
|
|
deviceClassOpenweathermap.setName("Weather from openweathermap.org");
|
|
deviceClassOpenweathermap.setCreateMethod(DeviceClass::CreateMethodDiscovery);
|
|
|
|
// Params
|
|
QVariantList params;
|
|
QVariantMap locationParam;
|
|
locationParam.insert("name", "location");
|
|
locationParam.insert("type", "string");
|
|
params.append(locationParam);
|
|
|
|
QVariantMap countryParam;
|
|
countryParam.insert("name", "country");
|
|
countryParam.insert("type", "string");
|
|
params.append(countryParam);
|
|
|
|
QVariantMap idParam;
|
|
idParam.insert("name", "id");
|
|
idParam.insert("type", "string");
|
|
params.append(idParam);
|
|
|
|
deviceClassOpenweathermap.setParams(params);
|
|
|
|
// Actions
|
|
QList<ActionType> weatherActions;
|
|
ActionType updateWeather(updateWeatherActionTypeId);
|
|
updateWeather.setName("refresh");
|
|
weatherActions.append(updateWeather);
|
|
|
|
// States
|
|
QList<StateType> weatherStates;
|
|
StateType updateTimeState(updateTimeStateTypeId);
|
|
updateTimeState.setName("last update [unixtime]");
|
|
updateTimeState.setType(QVariant::UInt);
|
|
updateTimeState.setDefaultValue(0);
|
|
weatherStates.append(updateTimeState);
|
|
|
|
StateType temperatureState(temperatureStateTypeId);
|
|
temperatureState.setName("temperature [Celsius]");
|
|
temperatureState.setType(QVariant::Double);
|
|
temperatureState.setDefaultValue(-999.9);
|
|
weatherStates.append(temperatureState);
|
|
|
|
StateType temperatureMinState(temperatureMinStateTypeId);
|
|
temperatureMinState.setName("temperature minimum [Celsius]");
|
|
temperatureMinState.setType(QVariant::Double);
|
|
temperatureMinState.setDefaultValue(-999.9);
|
|
weatherStates.append(temperatureMinState);
|
|
|
|
StateType temperatureMaxState(temperatureMaxStateTypeId);
|
|
temperatureMaxState.setName("temperature maximum [Celsius]");
|
|
temperatureMaxState.setType(QVariant::Double);
|
|
temperatureMaxState.setDefaultValue(999.9);
|
|
weatherStates.append(temperatureMaxState);
|
|
|
|
StateType humidityState(humidityStateTypeId);
|
|
humidityState.setName("humidity [%]");
|
|
humidityState.setType(QVariant::Int);
|
|
humidityState.setDefaultValue(-1);
|
|
weatherStates.append(humidityState);
|
|
|
|
StateType pressureState(pressureStateTypeId);
|
|
pressureState.setName("pressure [hPa]");
|
|
pressureState.setType(QVariant::Double);
|
|
pressureState.setDefaultValue(-1);
|
|
weatherStates.append(pressureState);
|
|
|
|
StateType windSpeedState(windSpeedStateTypeId);
|
|
windSpeedState.setName("wind speed [m/s]");
|
|
windSpeedState.setType(QVariant::Double);
|
|
windSpeedState.setDefaultValue(-1);
|
|
weatherStates.append(windSpeedState);
|
|
|
|
StateType windDirectionState(windDirectionStateTypeId);
|
|
windDirectionState.setName("wind direction [degree]");
|
|
windDirectionState.setType(QVariant::Int);
|
|
windDirectionState.setDefaultValue(-1);
|
|
weatherStates.append(windDirectionState);
|
|
|
|
StateType cloudinessState(cloudinessStateTypeId);
|
|
cloudinessState.setName("cloudiness [%]");
|
|
cloudinessState.setType(QVariant::Int);
|
|
cloudinessState.setDefaultValue(-1);
|
|
weatherStates.append(cloudinessState);
|
|
|
|
StateType weatherDescriptionState(weatherDescriptionStateTypeId);
|
|
weatherDescriptionState.setName("weather description");
|
|
weatherDescriptionState.setType(QVariant::String);
|
|
weatherDescriptionState.setDefaultValue("");
|
|
weatherStates.append(weatherDescriptionState);
|
|
|
|
StateType sunsetState(sunsetStateTypeId);
|
|
sunsetState.setName("sunset [unixtime]");
|
|
sunsetState.setType(QVariant::UInt);
|
|
sunsetState.setDefaultValue(0);
|
|
weatherStates.append(sunsetState);
|
|
|
|
StateType sunriseState(sunriseStateTypeId);
|
|
sunriseState.setName("sunrise [unixtime]");
|
|
sunriseState.setType(QVariant::UInt);
|
|
sunriseState.setDefaultValue(0);
|
|
weatherStates.append(sunriseState);
|
|
|
|
deviceClassOpenweathermap.setActions(weatherActions);
|
|
deviceClassOpenweathermap.setStates(weatherStates);
|
|
|
|
ret.append(deviceClassOpenweathermap);
|
|
return ret;
|
|
}
|
|
|
|
DeviceManager::DeviceError DevicePluginOpenweathermap::discoverDevices(const DeviceClassId &deviceClassId, const QVariantMap ¶ms) const
|
|
{
|
|
qDebug() << "should discover divces for" << deviceClassId << params.value("location").toString();
|
|
if(params.value("location").toString() == ""){
|
|
m_openweaher->searchAutodetect();
|
|
return DeviceManager::DeviceErrorNoError;
|
|
}
|
|
m_openweaher->search(params.value("location").toString());
|
|
return DeviceManager::DeviceErrorNoError;
|
|
}
|
|
|
|
bool DevicePluginOpenweathermap::deviceCreated(Device *device)
|
|
{
|
|
m_openweaher->update(device->params().value("id").toString());
|
|
return true;
|
|
}
|
|
|
|
DeviceManager::HardwareResources DevicePluginOpenweathermap::requiredHardware() const
|
|
{
|
|
return DeviceManager::HardwareResourceTimer;
|
|
}
|
|
|
|
DeviceManager::DeviceError DevicePluginOpenweathermap::executeAction(Device *device, const Action &action)
|
|
{
|
|
qDebug() << "execute action " << updateWeatherActionTypeId.toString();
|
|
if(action.actionTypeId() == updateWeatherActionTypeId){
|
|
m_openweaher->update(device->params().value("id").toString());
|
|
}
|
|
return DeviceManager::DeviceErrorNoError;
|
|
}
|
|
|
|
QString DevicePluginOpenweathermap::pluginName() const
|
|
{
|
|
return "Openweathermap";
|
|
}
|
|
|
|
PluginId DevicePluginOpenweathermap::pluginId() const
|
|
{
|
|
return PluginId("bc6af567-2338-41d5-aac1-462dec6e4783");
|
|
}
|
|
|
|
void DevicePluginOpenweathermap::guhTimer()
|
|
{
|
|
foreach (Device *device, deviceManager()->findConfiguredDevices(openweathermapDeviceClassId)) {
|
|
m_openweaher->update(device->params().value("id").toString());
|
|
}
|
|
}
|
|
|
|
void DevicePluginOpenweathermap::searchResultsReady(const QList<QVariantMap> &cityList)
|
|
{
|
|
QList<DeviceDescriptor> retList;
|
|
foreach (QVariantMap elemant, cityList) {
|
|
DeviceDescriptor descriptor(openweathermapDeviceClassId, elemant.value("name").toString(),elemant.value("country").toString());
|
|
QVariantMap params;
|
|
params.insert("location", elemant.value("name"));
|
|
params.insert("country", elemant.value("country"));
|
|
params.insert("id", elemant.value("id"));
|
|
descriptor.setParams(params);
|
|
retList.append(descriptor);
|
|
}
|
|
emit devicesDiscovered(openweathermapDeviceClassId,retList);
|
|
}
|
|
|
|
void DevicePluginOpenweathermap::weatherDataReady(const QByteArray &data)
|
|
{
|
|
QJsonParseError error;
|
|
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
|
|
|
|
if(error.error != QJsonParseError::NoError) {
|
|
qWarning() << "failed to parse data" << data << ":" << error.errorString();
|
|
return;
|
|
}
|
|
|
|
QVariantMap dataMap = jsonDoc.toVariant().toMap();
|
|
|
|
foreach (Device *device, deviceManager()->findConfiguredDevices(openweathermapDeviceClassId)) {
|
|
if(device->params().value("id").toString() == dataMap.value("id").toString()){
|
|
|
|
if(dataMap.contains("clouds")){
|
|
int cloudiness = dataMap.value("clouds").toMap().value("all").toInt();
|
|
device->setStateValue(cloudinessStateTypeId,cloudiness);
|
|
}
|
|
if(dataMap.contains("dt")){
|
|
uint lastUpdate = dataMap.value("dt").toUInt();
|
|
device->setStateValue(updateTimeStateTypeId,lastUpdate);
|
|
}
|
|
|
|
if(dataMap.contains("main")){
|
|
double temperatur = dataMap.value("main").toMap().value("temp").toDouble();
|
|
double temperaturMax = dataMap.value("main").toMap().value("temp_max").toDouble();
|
|
double temperaturMin = dataMap.value("main").toMap().value("temp_min").toDouble();
|
|
double pressure = dataMap.value("main").toMap().value("pressure").toDouble();
|
|
int humidity = dataMap.value("main").toMap().value("humidity").toInt();
|
|
|
|
device->setStateValue(temperatureStateTypeId,temperatur);
|
|
device->setStateValue(temperatureMinStateTypeId,temperaturMin);
|
|
device->setStateValue(temperatureMaxStateTypeId,temperaturMax);
|
|
device->setStateValue(pressureStateTypeId,pressure);
|
|
device->setStateValue(humidityStateTypeId,humidity);
|
|
}
|
|
|
|
if(dataMap.contains("sys")){
|
|
uint sunrise = dataMap.value("sys").toMap().value("sunrise").toUInt();
|
|
uint sunset = dataMap.value("sys").toMap().value("sunset").toUInt();
|
|
|
|
device->setStateValue(sunriseStateTypeId,sunrise);
|
|
device->setStateValue(sunsetStateTypeId,sunset);
|
|
}
|
|
|
|
if(dataMap.contains("weather")){
|
|
QString description = dataMap.value("weather").toMap().value("description").toString();
|
|
device->setStateValue(weatherDescriptionStateTypeId,description);
|
|
}
|
|
|
|
if(dataMap.contains("wind")){
|
|
int windDirection = dataMap.value("wind").toMap().value("deg").toInt();
|
|
double windSpeed = dataMap.value("wind").toMap().value("speed").toDouble();
|
|
|
|
device->setStateValue(windDirectionStateTypeId,windDirection);
|
|
device->setStateValue(windSpeedStateTypeId,windSpeed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|