Revision control
++ // Copyright (C) 2024 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qgeopositioninfosource_wasm_p.h"
++ #include "qgeopositioninfosourcedispatcher_wasm_p.h"
++
++ #include <QtCore/QDebug>
++ #include <QtCore/QPermission>
++ #include <QtCore/QCoreApplication>
++
++ #include <emscripten/val.h>
++ #include <emscripten/bind.h>
++
++
++ // QGeoPositionInfoSource implemented using the Web Geolocation API
++
++ QT_BEGIN_NAMESPACE
++
++ typedef emscripten::val GeolocationCoordinates;
++
++ QGeoPositionInfoSourceWasm::QGeoPositionInfoSourceWasm(QObject *parent)
++ : QGeoPositionInfoSource(parent)
++ {
++ // QGeoPositionInfoSourceWasm should not be constructed if
++ // geolocation support is missing.
++ Q_ASSERT(!geolocation().isUndefined());
++
++ m_dispatcher = QGeoPositionInfoDispatcherWasm::instance();
++ m_instanceId = m_dispatcher->registerInfoSourceInstance(this);
++
++ successCallback = val::module_property("qtGeolocationPositionSuccess").call<val>("bind", val::undefined(), m_instanceId);
++ errorCallback = val::module_property("qtGeolocationPositionError").call<val>("bind", val::undefined(), m_instanceId);
++
++ }
++
++ Geolocation QGeoPositionInfoSourceWasm::geolocation()
++ {
++ return val::global("navigator")["geolocation"];
++ }
++
++ QGeoPositionInfoSourceWasm::~QGeoPositionInfoSourceWasm()
++ {
++ stopUpdates();
++ m_dispatcher->unregisterInfoSourceInstance(m_instanceId);
++ }
++
++ void QGeoPositionInfoSourceWasm::setUpdateInterval(int msec)
++ {
++ // If msec is 0 we send updates as data becomes available, otherwise we force msec to be equal
++ // to or larger than the minimum update interval.
++ if (msec != 0 && msec < minimumUpdateInterval())
++ msec = minimumUpdateInterval();
++
++ QGeoPositionInfoSource::setUpdateInterval(msec);
++ }
++
++ void QGeoPositionInfoSourceWasm::startUpdates()
++ {
++ if (m_updates_running) {
++ qDebug() << "startUpdates() is called, but an update is already running.";
++ return;
++ }
++
++ if (preferredPositioningMethods() == 0) {
++ m_lastError = QGeoPositionInfoSource::UnknownSourceError;
++ return;
++ }
++
++ m_updates_running = true;
++ m_lastError = QGeoPositionInfoSource::NoError;
++
++ val options = val::object();
++ options.set("maximumAge", 0);
++
++ if (preferredPositioningMethods() & PositioningMethod::SatellitePositioningMethods)
++ options.set("enableHighAccuracy", true);
++
++ m_handlerId = geolocation().call<val>("watchPosition", successCallback, errorCallback, options);
++ }
++
++ void QGeoPositionInfoSourceWasm::stopUpdates()
++ {
++ geolocation().call<void>("clearWatch", m_handlerId);
++ m_updates_running = false;
++ }
++
++ void QGeoPositionInfoSourceWasm::requestUpdate(int timeout)
++ {
++ if (timeout < minimumUpdateInterval()) {
++ emit errorOccurred(UpdateTimeoutError);
++ return;
++ }
++
++ if (m_singleUpdatePending) {
++ qDebug() << "requestUpdate() called while a previous update is still pending. Ignoring.";
++ return;
++ }
++
++ m_singleUpdatePending = true;
++ m_lastError = QGeoPositionInfoSource::NoError;
++
++ val options = val::object();
++ options.set("maximumAge", 0); // maximum cache age: 0: don't use cache
++ options.set("timeout", timeout);
++
++ if (preferredPositioningMethods() & PositioningMethod::SatellitePositioningMethods)
++ options.set("enableHighAccuracy", true);
++
++ geolocation().call<void>("getCurrentPosition", successCallback, errorCallback, options);
++ }
++
++ QGeoPositionInfoSource::PositioningMethods QGeoPositionInfoSourceWasm::supportedPositioningMethods() const
++ {
++ return QGeoPositionInfoSource::AllPositioningMethods;
++ }
++
++ void QGeoPositionInfoSourceWasm::setPreferredPositioningMethods(PositioningMethods methods)
++ {
++ PositioningMethods previousPreferredPositioningMethods = preferredPositioningMethods();
++ QGeoPositionInfoSource::setPreferredPositioningMethods(methods);
++ if (previousPreferredPositioningMethods == preferredPositioningMethods())
++ return;
++
++ if (m_updates_running)
++ reconfigureRunningSystem();
++ }
++
++
++ int QGeoPositionInfoSourceWasm::minimumUpdateInterval() const
++ {
++ return 1000;
++ }
++
++ QGeoPositionInfo QGeoPositionInfoSourceWasm::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const
++ {
++ Q_UNUSED(fromSatellitePositioningMethodsOnly);
++ return m_lastKnownPosition;
++ }
++
++ QGeoPositionInfoSource::Error QGeoPositionInfoSourceWasm::error() const
++ {
++ qDebug() << "QGeoPositionInfoSourceWasm::error";
++ return m_lastError;
++ }
++
++ void QGeoPositionInfoSourceWasm::geolocationSuccess(GeolocationPosition position)
++ {
++ // Populate a QGeoPositionInfo from the native GeolocationPosition. Some
++ // attributes are optional and may be null.
++ QGeoPositionInfo info;
++ info.setTimestamp(QDateTime::fromMSecsSinceEpoch(position["timestamp"].as<double>()));
++
++ GeolocationCoordinates coords = position["coords"];
++ val latitude = coords["latitude"];
++ val longitude = coords["longitude"];
++ val altitude = coords["altitude"];
++ info.setCoordinate(altitude.isNull() ?
++ QGeoCoordinate(latitude.as<double>(), longitude.as<double>()) :
++ QGeoCoordinate(latitude.as<double>(), longitude.as<double>(), altitude.as<double>())
++ );
++
++ if (val speed = coords["speed"]; !speed.isNull())
++ info.setAttribute(QGeoPositionInfo::GroundSpeed, speed.as<double>());
++ if (val heading = coords["heading"]; !heading.isNull())
++ info.setAttribute(QGeoPositionInfo::Direction, heading.as<double>());
++
++ info.setAttribute(QGeoPositionInfo::HorizontalAccuracy, coords["accuracy"].as<double>());
++ if (val altitudeAccuracy = coords["altitudeAccuracy"]; !altitudeAccuracy.isNull())
++ info.setAttribute(QGeoPositionInfo::VerticalAccuracy, altitudeAccuracy.as<double>());
++
++ m_lastKnownPosition = info;
++ m_singleUpdatePending = false;
++
++ emit positionUpdated(info);
++ }
++
++ void QGeoPositionInfoSourceWasm::geolocationError(GeolocationPositionError error)
++ {
++ qDebug() << "geolocationError";
++ qDebug() << "Handler ID:" << m_handlerId.as<int>();
++
++ int code = error["code"].as<int>();
++ QString message = error["message"].as<QString>();
++
++ QGeoPositionInfoSource::Error qtError = QGeoPositionInfoSource::UnknownSourceError;
++
++ switch (code) {
++ case 1:
++ qtError = QGeoPositionInfoSource::AccessError; // -> PERMISSION_DENIED
++ break;
++ case 2:
++ qtError = QGeoPositionInfoSource::UnknownSourceError; // -> POSITION_UNAVAILABLE
++ break;
++ case 3:
++ qtError = QGeoPositionInfoSource::UpdateTimeoutError; // -> TIMEOUT
++ break;
++ }
++
++ qDebug() << "Message: " << message;
++
++ m_lastError = qtError;
++ m_singleUpdatePending = false;
++
++ emit errorOccurred(qtError);
++ }
++
++ void QGeoPositionInfoSourceWasm::reconfigureRunningSystem()
++ {
++ if (!m_updates_running)
++ return;
++
++ stopUpdates();
++ startUpdates();
++ }
++
++
++ QT_END_NAMESPACE
++
++ #include "moc_qgeopositioninfosource_wasm_p.cpp"