En esta página

Información meteorológica

El ejemplo «Información meteorológica» muestra cómo utilizar la posición actual del usuario para recuperar contenido local de un servicio web en un complemento de C++ para Qt Quick, utilizando Qt Positioning.

Clases Qt Positioning utilizadas en este ejemplo:

Ejemplo de pantalla de información meteorológica

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

Proveedores de datos meteorológicos

El ejemplo utiliza varios proveedores de datos meteorológicos independientes entre sí:

El proveedor que se va a utilizar se selecciona automáticamente en tiempo de ejecución y se puede cambiar si el proveedor seleccionado no está disponible. Sin embargo, no se puede especificar manualmente.

Nota: Se utilizan planesgratuitos para todos los proveedores, lo que implica ciertas limitaciones en el número de solicitudes meteorológicas. Si se superan los límites, los proveedores dejan de estar disponibles temporalmente. Cuando ninguno de los proveedores está disponible, la aplicación no podrá mostrar ninguna información meteorológica. En este caso, es necesario esperar hasta que al menos uno de los proveedores vuelva a estar disponible.

Modelos de datos de la aplicación

La parte fundamental de este ejemplo es el modelo de datos de la aplicación, contenido en las clases ` WeatherData ` y ` AppModel `. ` WeatherData ` representa la información meteorológica obtenida del servicio HTTP. Se trata de una clase de datos sencilla, pero utilizamos ` Q_PROPERTY ` para exponerla correctamente en QML más adelante. También utiliza la macro ` QML_ANONYMOUS `, que hace que sea reconocida en QML.

class WeatherData : public QObject {
    Q_OBJECT
    Q_PROPERTY(QString dayOfWeek
               READ dayOfWeek WRITE setDayOfWeek
               NOTIFY dataChanged)
    Q_PROPERTY(QString weatherIcon
               READ weatherIcon WRITE setWeatherIcon
               NOTIFY dataChanged)
    Q_PROPERTY(QString weatherDescription
               READ weatherDescription WRITE setWeatherDescription
               NOTIFY dataChanged)
    Q_PROPERTY(QString temperature
               READ temperature WRITE setTemperature
               NOTIFY dataChanged)
    QML_ANONYMOUS

public:
    explicit WeatherData(QObject *parent = 0);
    WeatherData(const WeatherData &other);
    WeatherData(const WeatherInfo &other);

    QString dayOfWeek() const;
    QString weatherIcon() const;
    QString weatherDescription() const;
    QString temperature() const;

    void setDayOfWeek(const QString &value);
    void setWeatherIcon(const QString &value);
    void setWeatherDescription(const QString &value);
    void setTemperature(const QString &value);

signals:
    void dataChanged();
};

AppModel modela el estado de toda la aplicación. Al iniciarse, obtenemos la fuente de posición predeterminada de la plataforma mediante QGeoPositionInfoSource::createDefaultSource().

AppModel::AppModel(QObject*parent) :
        QObject(parent),
        d(new AppModelPrivate)
{
    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);
}

Si no hay ninguna fuente predeterminada disponible, tomamos una posición estática y recuperamos la información meteorológica correspondiente. Sin embargo, si disponemos de una fuente de posición, conectamos su señal positionUpdated() a una ranura del AppModel y llamamos a startUpdates(), lo que inicia las actualizaciones periódicas de la posición del dispositivo.

Cuando se recibe una actualización de posición, utilizamos la longitud y la latitud de las coordenadas devueltas para recuperar los datos meteorológicos de la ubicación especificada.

void AppModel::positionUpdated(QGeoPositionInfo gpsPos)
{
    d->coord = gpsPos.coordinate();

    if (!d->useGps)
        return;

    requestWeatherByCoordinates();
}

Para informar a la interfaz de usuario sobre este proceso, se emite la señal « cityChanged() » cuando se utiliza una nueva ciudad, y la señal « weatherChanged() » cada vez que se produce una actualización meteorológica.

El modelo también utiliza la macro « QML_ELEMENT », lo que permite utilizarla en QML.

class AppModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool ready
               READ ready
               NOTIFY readyChanged)
    Q_PROPERTY(bool hasSource
               READ hasSource
               NOTIFY readyChanged)
    Q_PROPERTY(bool hasValidCity
               READ hasValidCity
               NOTIFY cityChanged)
    Q_PROPERTY(bool hasValidWeather
               READ hasValidWeather
               NOTIFY weatherChanged)
    Q_PROPERTY(bool useGps
               READ useGps WRITE setUseGps
               NOTIFY useGpsChanged)
    Q_PROPERTY(QString city
               READ city WRITE setCity
               NOTIFY cityChanged)
    Q_PROPERTY(WeatherData *weather
               READ weather
               NOTIFY weatherChanged)
    Q_PROPERTY(QQmlListProperty<WeatherData> forecast
               READ forecast
               NOTIFY weatherChanged)
    QML_ELEMENT

public:
    explicit AppModel(QObject *parent = 0);
    ~AppModel();

    bool ready() const;
    bool hasSource() const;
    bool useGps() const;
    bool hasValidCity() const;
    bool hasValidWeather() const;
    void setUseGps(bool value);

    QString city() const;
    void setCity(const QString &value);

    WeatherData *weather() const;
    QQmlListProperty<WeatherData> forecast() const;

public slots:
    Q_INVOKABLE void refreshWeather();

signals:
    void readyChanged();
    void useGpsChanged();
    void cityChanged();
    void weatherChanged();
};

Utilizamos un ` QQmlListProperty ` para la información de la previsión meteorológica, que contiene la previsión para los próximos días (el número de días depende del proveedor). Esto facilita el acceso a la previsión desde QML.

Exponer modelos personalizados en QML

Para exponer los modelos a la capa de interfaz de usuario de QML, utilizamos las macros QML_ELEMENT y QML_ANONYMOUS. Consulte la descripción de la clase QQmlEngine para obtener más detalles sobre estas macros.

Para que los tipos estén disponibles en QML, debemos actualizar nuestra compilación en consecuencia.

Compilación con CMake

Para una compilación basada en CMake, debemos añadir lo siguiente al archivo ` CMakeLists.txt`:

qt_add_qml_module(weatherinfo
    URI Weather
    VERSION 1.0
    SOURCES
        appmodel.cpp appmodel.h
        openmeteobackend.cpp openmeteobackend.h
        openweathermapbackend.cpp openweathermapbackend.h
        providerbackend.cpp providerbackend.h
        weatherapibackend.cpp weatherapibackend.h
    QML_FILES
        BigForecastIcon.qml
        ForecastIcon.qml
        WeatherIcon.qml
        WeatherInfo.qml
    RESOURCES
        icons/weather-few-clouds.svg
        icons/weather-fog.svg
        icons/weather-haze.svg
        icons/weather-icy.svg
        icons/weather-overcast.svg
        icons/weather-showers.svg
        icons/weather-sleet.svg
        icons/weather-snow.svg
        icons/weather-storm.svg
        icons/weather-sunny-very-few-clouds.svg
        icons/weather-sunny.svg
        icons/weather-thundershower.svg
        icons/weather-showers-scattered.svg
        icons/waypoint.svg
)
Compilación con qmake

Para una compilación con qmake, debemos modificar el archivo weatherinfo.pro de la siguiente manera:

CONFIG += qmltypes
QML_IMPORT_NAME = Weather
QML_IMPORT_MAJOR_VERSION = 1

qml_resources.files = \
    qmldir \
    BigForecastIcon.qml \
    ForecastIcon.qml \
    WeatherIcon.qml \
    WeatherInfo.qml \
    icons/weather-few-clouds.svg \
    icons/weather-fog.svg \
    icons/weather-haze.svg \
    icons/weather-icy.svg \
    icons/weather-overcast.svg \
    icons/weather-showers.svg \
    icons/weather-showers-scattered.svg \
    icons/weather-sleet.svg \
    icons/weather-snow.svg \
    icons/weather-storm.svg \
    icons/weather-sunny-very-few-clouds.svg \
    icons/weather-sunny.svg \
    icons/weather-thundershower.svg \
    icons/waypoint.svg

qml_resources.prefix = /qt/qml/Weather

RESOURCES += qml_resources

Instanciar los modelos en QML

Por último, en el propio QML, instanciamos el ` AppModel`:

Window {
    id: window
    AppModel {
        id: appModel
        onReadyChanged: {
            if (appModel.ready)
                statesItem.state = "ready"
            else
                statesItem.state = "loading"
        }
    }
}

Una vez instanciado el modelo de esta forma, podemos utilizar sus propiedades en cualquier otra parte del documento QML:

    BigForecastIcon {
        id: current
        Layout.fillWidth: true
        Layout.fillHeight: true

        weatherIcon: (appModel.hasValidWeather
                      ? appModel.weather.weatherIcon
                      : "sunny")
    }

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.