Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include "appmodel.h"
#include "openmeteobackend.h"
#include "openweathermapbackend.h"
#include "weatherapibackend.h"
#include <QtPositioning/qgeocircle.h>
#include <QtPositioning/qgeocoordinate.h>
#if QT_CONFIG(permissions)
#include <QtCore/qpermissions.h>
#endif
#include <QtCore/qcoreapplication.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qtimer.h>
Q_LOGGING_CATEGORY(requestsLog, "wapp.requests")
WeatherData::WeatherData(QObject *parent) :
QObject(parent)
{
}
WeatherData::WeatherData(const WeatherData &other) :
QObject(nullptr),
m_dayOfWeek(other.m_dayOfWeek),
m_weather(other.m_weather),
m_weatherDescription(other.m_weatherDescription),
m_temperature(other.m_temperature)
{
}
WeatherData::WeatherData(const WeatherInfo &other)
: QObject(nullptr),
m_dayOfWeek(other.m_dayOfWeek),
m_weather(other.m_weatherIconId),
m_weatherDescription(other.m_weatherDescription),
m_temperature(other.m_temperature)
{
}
QString WeatherData::dayOfWeek() const
{
return m_dayOfWeek;
}
QString WeatherData::weatherIcon() const
{
return m_weather;
}
QString WeatherData::weatherDescription() const
{
return m_weatherDescription;
}
QString WeatherData::temperature() const
{
return m_temperature;
}
void WeatherData::setDayOfWeek(const QString &value)
{
m_dayOfWeek = value;
emit dataChanged();
}
void WeatherData::setWeatherIcon(const QString &value)
{
m_weather = value;
emit dataChanged();
}
void WeatherData::setWeatherDescription(const QString &value)
{
m_weatherDescription = value;
emit dataChanged();
}
void WeatherData::setTemperature(const QString &value)
{
m_temperature = value;
emit dataChanged();
}
/*
The class is used as a cache for the weather information.
It contains a map to cache weather for cities.
The gps location is cached separately.
For the coordiante search we do not compare the coordinate directly, but
check if it's within a circle of 3 km radius (we assume that the weather
does not really change within that radius).
The cache returns a pair with empty location and weather data if no data
is found, or if the data is outdated.
*/
class WeatherDataCache
{
public:
WeatherDataCache() = default;
using WeatherDataPair = QPair<QString, QList<WeatherInfo>>;
WeatherDataPair getWeatherData(const QString &name) const;
WeatherDataPair getWeatherData(const QGeoCoordinate &coordinate) const;
void addCacheElement(const LocationInfo &location, const QList<WeatherInfo> &info);
static bool isCacheResultValid(const WeatherDataPair &result);
private:
struct CacheItem
{
qint64 m_cacheTime;
QList<WeatherInfo> m_weatherData;
};
QMap<QString, CacheItem> m_cityCache;
QGeoCoordinate m_gpsLocation;
QString m_gpsName;
CacheItem m_gpsData;
static const qint64 kCacheTimeoutInterval = 3600; // 1 hour
static const int kCircleRadius = 3000; // 3 km
};
WeatherDataCache::WeatherDataPair WeatherDataCache::getWeatherData(const QString &name) const
{
if (m_cityCache.contains(name)) {
const qint64 currentTime = QDateTime::currentSecsSinceEpoch();
const auto &item = m_cityCache.value(name);
if (currentTime - item.m_cacheTime < kCacheTimeoutInterval)
return qMakePair(name, item.m_weatherData);
}
return qMakePair(QString(), QList<WeatherInfo>());
}
WeatherDataCache::WeatherDataPair
WeatherDataCache::getWeatherData(const QGeoCoordinate &coordinate) const
{
if (m_gpsLocation.isValid() && !m_gpsName.isEmpty()) {
const QGeoCircle area(m_gpsLocation, kCircleRadius);
if (area.contains(coordinate)) {
const qint64 currentTime = QDateTime::currentSecsSinceEpoch();
if (currentTime - m_gpsData.m_cacheTime < kCacheTimeoutInterval)
return qMakePair(m_gpsName, m_gpsData.m_weatherData);
}
}
return qMakePair(QString(), QList<WeatherInfo>());
}
void WeatherDataCache::addCacheElement(const LocationInfo &location,
const QList<WeatherInfo> &info)
{
// It it expected that we have valid QGeoCoordinate only when the weather
// is received based on coordinates.
const qint64 currentTime = QDateTime::currentSecsSinceEpoch();
if (location.m_coordinate.isValid()) {
m_gpsLocation = location.m_coordinate;
m_gpsName = location.m_name;
m_gpsData = { currentTime, info };
} else {
m_cityCache[location.m_name] = { currentTime, info };
}
}
bool WeatherDataCache::isCacheResultValid(const WeatherDataCache::WeatherDataPair &result)
{
return !result.first.isEmpty() && !result.second.isEmpty();
}
class AppModelPrivate
{
public:
QGeoPositionInfoSource *src = nullptr;
QGeoCoordinate coord;
QString city;
WeatherData now;
QList<WeatherData*> forecast;
QQmlListProperty<WeatherData> *fcProp = nullptr;
bool ready = false;
bool useGps = true;
WeatherDataCache m_dataCache;
ProviderBackend *m_currentBackend = nullptr;
QList<ProviderBackend*> m_supportedBackends;
qsizetype m_currentBackendIndex = 0;
};
static void forecastAppend(QQmlListProperty<WeatherData> *prop, WeatherData *val)
{
Q_UNUSED(val);
Q_UNUSED(prop);
}
static WeatherData *forecastAt(QQmlListProperty<WeatherData> *prop, qsizetype index)
{
AppModelPrivate *d = static_cast<AppModelPrivate*>(prop->data);
return d->forecast.at(index);
}
static qsizetype forecastCount(QQmlListProperty<WeatherData> *prop)
{
AppModelPrivate *d = static_cast<AppModelPrivate*>(prop->data);
return d->forecast.size();
}
static void forecastClear(QQmlListProperty<WeatherData> *prop)
{
static_cast<AppModelPrivate*>(prop->data)->forecast.clear();
}
//! [0]
AppModel::AppModel(QObject *parent) :
QObject(parent),
d(new AppModelPrivate)
{
//! [0]
d->fcProp = new QQmlListProperty<WeatherData>(this, d, forecastAppend,
forecastCount,
forecastAt,
forecastClear);
d->m_supportedBackends.push_back(new OpenWeatherMapBackend(this));
d->m_supportedBackends.push_back(new WeatherApiBackend(this));
d->m_supportedBackends.push_back(new OpenMeteoBackend(this));
registerBackend(0);
//! [1]
d->src = QGeoPositionInfoSource::createDefaultSource(this);
if (d->src) {
d->useGps = true;
connect(d->src, &QGeoPositionInfoSource::positionUpdated,
this, &AppModel::positionUpdated);
connect(d->src, &QGeoPositionInfoSource::errorOccurred,
this, &AppModel::positionError);
#if QT_CONFIG(permissions)
QLocationPermission permission;
permission.setAccuracy(QLocationPermission::Precise);
permission.setAvailability(QLocationPermission::WhenInUse);
switch (qApp->checkPermission(permission)) {
case Qt::PermissionStatus::Undetermined:
qApp->requestPermission(permission, [this] (const QPermission& permission) {
if (permission.status() == Qt::PermissionStatus::Granted)
d->src->startUpdates();
else
positionError(QGeoPositionInfoSource::AccessError);
});
break;
case Qt::PermissionStatus::Denied:
qWarning("Location permission is denied");
positionError(QGeoPositionInfoSource::AccessError);
break;
case Qt::PermissionStatus::Granted:
d->src->startUpdates();
break;
}
#else
d->src->startUpdates();
#endif
} else {
d->useGps = false;
d->city = "Brisbane";
emit cityChanged();
requestWeatherByCity();
}
QTimer *refreshTimer = new QTimer(this);
connect(refreshTimer, &QTimer::timeout, this, &AppModel::refreshWeather);
using namespace std::chrono;
refreshTimer->start(60s);
}
//! [1]
AppModel::~AppModel()
{
if (d->src)
d->src->stopUpdates();
if (d->fcProp)
delete d->fcProp;
qDeleteAll(d->forecast);
delete d;
}
//! [2]
void AppModel::positionUpdated(QGeoPositionInfo gpsPos)
{
d->coord = gpsPos.coordinate();
if (!d->useGps)
return;
requestWeatherByCoordinates();
}
//! [2]
void AppModel::positionError(QGeoPositionInfoSource::Error e)
{
Q_UNUSED(e);
qWarning() << "Position source error. Falling back to simulation mode.";
// activate simulation mode
if (d->useGps) {
d->useGps = false;
d->city = "Brisbane";
emit cityChanged();
requestWeatherByCity();
}
}
void AppModel::refreshWeather()
{
if (d->city.isEmpty()) {
qCDebug(requestsLog) << "refreshing weather skipped (no city)";
return;
}
qCDebug(requestsLog) << "refreshing weather";
requestWeatherByCity();
}
void AppModel::handleWeatherData(const LocationInfo &location,
const QList<WeatherInfo> &weatherDetails)
{
if (applyWeatherData(location.m_name, weatherDetails))
d->m_dataCache.addCacheElement(location, weatherDetails);
}
void AppModel::switchToNextBackend()
{
deregisterCurrentBackend();
registerBackend(d->m_currentBackendIndex + 1);
if (d->m_currentBackend) {
// repeat the query
if (d->useGps)
requestWeatherByCoordinates();
else
requestWeatherByCity();
} else {
qWarning("The application has iterated through all of the weather backends, "
"and none of them seems to respond now. Please wait until any of the "
"backends becomes available again.");
}
}
bool AppModel::applyWeatherData(const QString &city, const QList<WeatherInfo> &weatherDetails)
{
// Check that we didn't get outdated weather data. The city should match,
// if only we do not use GPS.
if (city != d->city && !d->useGps)
return false;
if (city != d->city && d->useGps) {
d->city = city;
emit cityChanged();
}
// delete previous forecast
qDeleteAll(d->forecast);
d->forecast.clear();
// The first item in the list represents current weather.
if (!weatherDetails.isEmpty()) {
d->now.setTemperature(weatherDetails.first().m_temperature);
d->now.setWeatherIcon(weatherDetails.first().m_weatherIconId);
d->now.setWeatherDescription(weatherDetails.first().m_weatherDescription);
}
// The other items represent weather forecast. The amount of items depends
// on the provider backend.
for (qsizetype i = 1; i < weatherDetails.size(); ++i) {
WeatherData *forecastEntry = new WeatherData(weatherDetails.at(i));
d->forecast.append(forecastEntry);
}
if (!d->ready) {
d->ready = true;
emit readyChanged();
}
emit weatherChanged();
return true;
}
void AppModel::requestWeatherByCoordinates()
{
const auto cacheResult = d->m_dataCache.getWeatherData(d->coord);
if (WeatherDataCache::isCacheResultValid(cacheResult))
applyWeatherData(cacheResult.first, cacheResult.second);
else if (d->m_currentBackend)
d->m_currentBackend->requestWeatherInfo(d->coord);
}
void AppModel::requestWeatherByCity()
{
const auto cacheResult = d->m_dataCache.getWeatherData(d->city);
if (WeatherDataCache::isCacheResultValid(cacheResult))
applyWeatherData(cacheResult.first, cacheResult.second);
else if (d->m_currentBackend)
d->m_currentBackend->requestWeatherInfo(d->city);
}
void AppModel::registerBackend(qsizetype index)
{
if (index >= 0 && index < d->m_supportedBackends.size()) {
d->m_currentBackend = d->m_supportedBackends.at(index);
d->m_currentBackendIndex = index;
connect(d->m_currentBackend, &ProviderBackend::weatherInformation,
this, &AppModel::handleWeatherData);
connect(d->m_currentBackend, &ProviderBackend::errorOccurred,
this, &AppModel::switchToNextBackend);
}
}
void AppModel::deregisterCurrentBackend()
{
if (d->m_currentBackend) {
disconnect(d->m_currentBackend, &ProviderBackend::weatherInformation,
this, &AppModel::handleWeatherData);
disconnect(d->m_currentBackend, &ProviderBackend::errorOccurred,
this, &AppModel::switchToNextBackend);
d->m_currentBackend = nullptr;
}
}
bool AppModel::hasValidCity() const
{
return (!(d->city.isEmpty()) && d->city.size() > 1 && d->city != "");
}
bool AppModel::hasValidWeather() const
{
return hasValidCity() && (!(d->now.weatherIcon().isEmpty()) &&
(d->now.weatherIcon().size() > 1) &&
d->now.weatherIcon() != "");
}
WeatherData *AppModel::weather() const
{
return &(d->now);
}
QQmlListProperty<WeatherData> AppModel::forecast() const
{
return *(d->fcProp);
}
bool AppModel::ready() const
{
return d->ready;
}
bool AppModel::hasSource() const
{
return (d->src != NULL);
}
bool AppModel::useGps() const
{
return d->useGps;
}
void AppModel::setUseGps(bool value)
{
d->useGps = value;
if (value) {
d->city = "";
emit cityChanged();
emit weatherChanged();
// if we already have a valid GPS position, do not wait until it
// updates, but query the city immediately
if (d->coord.isValid())
requestWeatherByCoordinates();
}
emit useGpsChanged();
}
QString AppModel::city() const
{
return d->city;
}
void AppModel::setCity(const QString &value)
{
d->city = value;
emit cityChanged();
requestWeatherByCity();
}