Make QGeoCameraCapabilities independent of the engine

This patch makes it possible to change QGeoCameraCapabilites
at runtime, when the map type changes, to accommodate for
those plugins that offer different maps having different
capabilities.
This is then used to properly push the  min/max zoom levels
for each map type in our OSM plugin.

Autotests are included.

Change-Id: I48532da77ffb3eaf2e752561395945c3a2c21985
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

13 files changed, 222 insertions, 92 deletions

diff --git a/src/location/declarativemaps/qdeclarativegeomap.cpp b/src/location/declarativemaps/qdeclarativegeomap.cpp
index 65828581..e4a707ab 100644
--- a/src/location/declarativemaps/qdeclarativegeomap.cpp
+++ b/src/location/declarativemaps/qdeclarativegeomap.cpp
@@ -174,7 +174,9 @@ QDeclarativeGeoMap::QDeclarativeGeoMap(QQuickItem *parent)
         m_pendingFitViewport(false),
         m_copyrightsVisible(true),
         m_maximumViewportLatitude(0.0),
-        m_initialized(false)
+        m_initialized(false),
+        m_userMinimumZoomLevel(qQNaN()),
+        m_userMaximumZoomLevel(qQNaN())
 {
     setAcceptHoverEvents(false);
     setAcceptedMouseButtons(Qt::LeftButton);
@@ -188,6 +190,16 @@ QDeclarativeGeoMap::QDeclarativeGeoMap(QQuickItem *parent)
                                                              tr("No Map"), false, false, 0), this);
     m_cameraData.setCenter(QGeoCoordinate(51.5073,-0.1277)); //London city center
     m_cameraData.setZoomLevel(8.0);
+
+    m_cameraCapabilities.setTileSize(256);
+    m_cameraCapabilities.setSupportsBearing(true);
+    m_cameraCapabilities.setSupportsTilting(true);
+    m_cameraCapabilities.setMinimumZoomLevel(0);
+    m_cameraCapabilities.setMaximumZoomLevel(30);
+    m_cameraCapabilities.setMinimumTilt(0);
+    m_cameraCapabilities.setMaximumTilt(89.5);
+    m_cameraCapabilities.setMinimumFieldOfView(1);
+    m_cameraCapabilities.setMaximumFieldOfView(179);
 }
 
 QDeclarativeGeoMap::~QDeclarativeGeoMap()
@@ -335,6 +347,10 @@ void QDeclarativeGeoMap::setError(QGeoServiceProvider::Error error, const QStrin
     emit errorChanged();
 }
 
+/*!
+    \internal
+    Called when the mapping manager is initialized AND the declarative element has a valid size > 0
+*/
 void QDeclarativeGeoMap::initialize()
 {
     // try to keep change signals in the end
@@ -342,38 +358,30 @@ void QDeclarativeGeoMap::initialize()
     bool bearingHasChanged = false;
     bool tiltHasChanged = false;
     bool fovHasChanged = false;
-    bool minTiltHasChanged = false;
-    bool maxTiltHasChanged = false;
-    bool minFovHasChanged = false;
-    bool maxFovHasChanged = false;
 
     QGeoCoordinate center = m_cameraData.center();
 
-    setMinimumZoomLevel(m_map->minimumZoom());
+    if (qIsNaN(m_userMinimumZoomLevel))
+        setMinimumZoomLevel(m_map->minimumZoom(), false);
+    else
+        setMinimumZoomLevel(qMax<qreal>(m_map->minimumZoom(), m_userMinimumZoomLevel), false);
 
     double bearing = m_cameraData.bearing();
     double tilt = m_cameraData.tilt();
     double fov = m_cameraData.fieldOfView(); // Must be 45.0
-    if (m_map->cameraCapabilities().minimumFieldOfView() != 1)
-        minFovHasChanged = true;
-    if (m_map->cameraCapabilities().maximumFieldOfView() != 179)
-        maxFovHasChanged = true;
-    if (m_map->cameraCapabilities().minimumTilt() != 0)
-        minTiltHasChanged = true;
-    if (m_map->cameraCapabilities().maximumTilt() != 89)
-        maxTiltHasChanged = true;
-    if (!m_map->cameraCapabilities().supportsBearing() && bearing != 0.0) {
+
+    if (!m_cameraCapabilities.supportsBearing() && bearing != 0.0) {
         m_cameraData.setBearing(0);
         bearingHasChanged = true;
     }
-    if (!m_map->cameraCapabilities().supportsTilting() && tilt != 0.0) {
+    if (!m_cameraCapabilities.supportsTilting() && tilt != 0.0) {
         m_cameraData.setTilt(0);
         tiltHasChanged = true;
     }
 
-    m_cameraData.setFieldOfView(qBound(m_map->cameraCapabilities().minimumFieldOfView(),
+    m_cameraData.setFieldOfView(qBound(m_cameraCapabilities.minimumFieldOfView(),
                                        fov,
-                                       m_map->cameraCapabilities().maximumFieldOfView()));
+                                       m_cameraCapabilities.maximumFieldOfView()));
     if (fov != m_cameraData.fieldOfView())
         fovHasChanged  = true;
 
@@ -402,18 +410,6 @@ void QDeclarativeGeoMap::initialize()
 
     if (fovHasChanged)
         emit fieldOfViewChanged(m_cameraData.fieldOfView());
-
-    if (minTiltHasChanged)
-        emit minimumTiltChanged(m_map->cameraCapabilities().minimumTilt());
-
-    if (maxTiltHasChanged)
-        emit maximumTiltChanged(m_map->cameraCapabilities().maximumTilt());
-
-    if (minFovHasChanged)
-        emit minimumFieldOfViewChanged(m_map->cameraCapabilities().minimumFieldOfView());
-
-    if (maxFovHasChanged)
-        emit maximumFieldOfViewChanged(m_map->cameraCapabilities().maximumFieldOfView());
 }
 
 /*!
@@ -631,6 +627,75 @@ void QDeclarativeGeoMap::setPlugin(QDeclarativeGeoServiceProvider *plugin)
 
 /*!
     \internal
+*/
+void QDeclarativeGeoMap::onCameraCapabilitiesChanged(const QGeoCameraCapabilities &oldCameraCapabilities)
+{
+    if (m_map->cameraCapabilities() == oldCameraCapabilities)
+        return;
+    m_cameraCapabilities = m_map->cameraCapabilities();
+
+    bool minTiltHasChanged = false;
+    bool maxTiltHasChanged = false;
+    bool minFovHasChanged = false;
+    bool maxFovHasChanged = false;
+
+    if (m_cameraCapabilities.minimumFieldOfView() != oldCameraCapabilities.minimumFieldOfView())
+        minFovHasChanged = true;
+    if (m_cameraCapabilities.maximumFieldOfView() != oldCameraCapabilities.maximumFieldOfView())
+        maxFovHasChanged = true;
+    if (m_cameraCapabilities.minimumTilt() != oldCameraCapabilities.minimumTilt())
+        minTiltHasChanged = true;
+    if (m_cameraCapabilities.maximumTilt() != oldCameraCapabilities.maximumTilt())
+        maxTiltHasChanged = true;
+
+    //The zoom level limits are only restricted by the plugins values, if the user has set a more
+    //strict zoom level limit before initialization nothing is done here.
+    //minimum zoom level might be changed to limit gray bundaries
+    //This code assumes that plugins' maximum zoom level will never exceed 30.0
+    if (m_cameraCapabilities.maximumZoomLevelAt256() < m_gestureArea->maximumZoomLevel()) {
+        setMaximumZoomLevel(m_cameraCapabilities.maximumZoomLevelAt256(), false);
+    } else if (m_cameraCapabilities.maximumZoomLevelAt256() > m_gestureArea->maximumZoomLevel()) {
+        if (qIsNaN(m_userMaximumZoomLevel)) {
+            // If the user didn't set anything
+            setMaximumZoomLevel(m_cameraCapabilities.maximumZoomLevelAt256(), false);
+        } else if (m_userMaximumZoomLevel > m_gestureArea->maximumZoomLevel()) {
+            // Else if the user set something larger, but that got clamped by the previous camera caps
+            setMaximumZoomLevel(qMin<qreal>(m_cameraCapabilities.maximumZoomLevelAt256(),
+                                            m_userMaximumZoomLevel), false);
+        }
+    }
+
+    if (m_cameraCapabilities.minimumZoomLevelAt256() > m_gestureArea->minimumZoomLevel()) {
+        setMinimumZoomLevel(m_cameraCapabilities.minimumZoomLevelAt256(), false);
+    } else if (m_cameraCapabilities.minimumZoomLevelAt256() < m_gestureArea->minimumZoomLevel()) {
+        if (qIsNaN(m_userMinimumZoomLevel)) {
+            // If the user didn't set anything, trying to set the new caps.
+            setMinimumZoomLevel(m_cameraCapabilities.minimumZoomLevelAt256(), false);
+        } else if (m_userMinimumZoomLevel < m_gestureArea->minimumZoomLevel()) {
+            // Else if the user set a minimum, m_gestureArea->minimumZoomLevel() might be larger
+            // because of different reasons. Resetting it, as if it ends to be the same,
+            // no signal will be emitted.
+            setMinimumZoomLevel(qMax<qreal>(m_cameraCapabilities.minimumZoomLevelAt256(),
+                                            m_userMinimumZoomLevel), false);
+        }
+    }
+
+    if (minTiltHasChanged)
+        emit minimumTiltChanged(m_cameraCapabilities.minimumTilt());
+
+    if (maxTiltHasChanged)
+        emit maximumTiltChanged(m_cameraCapabilities.maximumTilt());
+
+    if (minFovHasChanged)
+        emit minimumFieldOfViewChanged(m_cameraCapabilities.minimumFieldOfView());
+
+    if (maxFovHasChanged)
+        emit maximumFieldOfViewChanged(m_cameraCapabilities.maximumFieldOfView());
+}
+
+
+/*!
+    \internal
     this function will only be ever called once
 */
 void QDeclarativeGeoMap::mappingManagerInitialized()
@@ -656,16 +721,8 @@ void QDeclarativeGeoMap::mappingManagerInitialized()
         m_map->setActiveMapType(m_activeMapType->mapType());
     }
 
-    //The zoom level limits are only restricted by the plugins values, if the user has set a more
-    //strict zoom level limit before initialization nothing is done here.
-    //minimum zoom level might be changed to limit gray bundaries
-    //This code assumes that plugins' maximum zoom level will never exceed 30.0
-    if (m_map->cameraCapabilities().maximumZoomLevelAt256() < m_gestureArea->maximumZoomLevel())
-        setMaximumZoomLevel(m_map->cameraCapabilities().maximumZoomLevelAt256());
-
-    if (m_map->cameraCapabilities().minimumZoomLevelAt256() > m_gestureArea->minimumZoomLevel())
-        setMinimumZoomLevel(m_map->cameraCapabilities().minimumZoomLevelAt256());
-
+    // Update camera capabilities
+    onCameraCapabilitiesChanged(m_cameraCapabilities);
 
     // Map tiles are built in this call. m_map->minimumZoom() becomes operational
     // after this has been called at least once, after creation.
@@ -694,6 +751,7 @@ void QDeclarativeGeoMap::mappingManagerInitialized()
     connect(m_copyrights.data(), SIGNAL(linkActivated(QString)),
             this, SIGNAL(copyrightLinkActivated(QString)));
     connect(m_map, &QGeoMap::sgNodeChanged, this, &QQuickItem::update);
+    connect(m_map, &QGeoMap::cameraCapabilitiesChanged, this, &QDeclarativeGeoMap::onCameraCapabilitiesChanged);
 
     // set visibility of copyright notice
     m_copyrights->setCopyrightsVisible(m_copyrightsVisible);
@@ -748,18 +806,17 @@ QDeclarativeGeoServiceProvider *QDeclarativeGeoMap::plugin() const
     The minimum zoom level will also have a lower bound dependent on the size
     of the canvas, effectively preventing to display out of bounds areas.
 */
-void QDeclarativeGeoMap::setMinimumZoomLevel(qreal minimumZoomLevel)
+void QDeclarativeGeoMap::setMinimumZoomLevel(qreal minimumZoomLevel, bool userSet)
 {
 
     if (minimumZoomLevel >= 0) {
+        if (userSet)
+            m_userMinimumZoomLevel = minimumZoomLevel;
         qreal oldMinimumZoomLevel = this->minimumZoomLevel();
 
-        if (m_map) {
-            minimumZoomLevel = qBound(qreal(m_map->cameraCapabilities().minimumZoomLevelAt256()), minimumZoomLevel, maximumZoomLevel());
-            double minimumViewportZoomLevel = m_map->minimumZoom();
-            if (minimumZoomLevel < minimumViewportZoomLevel)
-                minimumZoomLevel = minimumViewportZoomLevel;
-        }
+        minimumZoomLevel = qBound(qreal(m_cameraCapabilities.minimumZoomLevelAt256()), minimumZoomLevel, maximumZoomLevel());
+        if (m_map)
+             minimumZoomLevel = qMax<qreal>(minimumZoomLevel, m_map->minimumZoom());
 
         m_gestureArea->setMinimumZoomLevel(minimumZoomLevel);
 
@@ -795,13 +852,14 @@ qreal QDeclarativeGeoMap::minimumZoomLevel() const
     Sets the gesture areas maximum zoom level. If the camera capabilities
     has been set this method honors the boundaries set by it.
 */
-void QDeclarativeGeoMap::setMaximumZoomLevel(qreal maximumZoomLevel)
+void QDeclarativeGeoMap::setMaximumZoomLevel(qreal maximumZoomLevel, bool userSet)
 {
     if (maximumZoomLevel >= 0) {
+        if (userSet)
+            m_userMaximumZoomLevel = maximumZoomLevel;
         qreal oldMaximumZoomLevel = this->maximumZoomLevel();
 
-        if (m_map)
-            maximumZoomLevel = qBound(minimumZoomLevel(), maximumZoomLevel, qreal(m_map->cameraCapabilities().maximumZoomLevelAt256()));
+        maximumZoomLevel = qBound(minimumZoomLevel(), maximumZoomLevel, qreal(m_cameraCapabilities.maximumZoomLevelAt256()));
 
         m_gestureArea->setMaximumZoomLevel(maximumZoomLevel);
 
@@ -882,7 +940,7 @@ void QDeclarativeGeoMap::setBearing(qreal bearing)
     bearing = std::fmod(bearing, qreal(360.0));
     if (bearing < 0.0)
         bearing += 360.0;
-    if (m_map && !m_map->cameraCapabilities().supportsBearing())
+    if (m_map && !m_cameraCapabilities.supportsBearing())
         bearing = 0.0;
     if (m_cameraData.bearing() == bearing || bearing < 0.0)
         return;
@@ -966,9 +1024,7 @@ qreal QDeclarativeGeoMap::fieldOfView() const
 */
 qreal QDeclarativeGeoMap::minimumFieldOfView() const
 {
-    if (!m_map)
-        return 1;
-    return m_map->cameraCapabilities().minimumFieldOfView();
+    return m_cameraCapabilities.minimumFieldOfView();
 }
 
 /*!
@@ -980,9 +1036,7 @@ qreal QDeclarativeGeoMap::minimumFieldOfView() const
 */
 qreal QDeclarativeGeoMap::maximumFieldOfView() const
 {
-    if (!m_map)
-        return 179;
-    return m_map->cameraCapabilities().maximumFieldOfView();
+    return m_cameraCapabilities.maximumFieldOfView();
 }
 
 /*!
@@ -995,9 +1049,7 @@ qreal QDeclarativeGeoMap::maximumFieldOfView() const
 */
 bool QDeclarativeGeoMap::isBearingSupported() const
 {
-    if (!m_map)
-        return false;
-    return m_map->cameraCapabilities().supportsBearing();
+    return m_cameraCapabilities.supportsBearing();
 }
 
 /*!
@@ -1010,9 +1062,7 @@ bool QDeclarativeGeoMap::isBearingSupported() const
 */
 bool QDeclarativeGeoMap::isTiltingSupported() const
 {
-    if (!m_map)
-        return false;
-    return m_map->cameraCapabilities().supportsTilting();
+    return m_cameraCapabilities.supportsTilting();
 }
 
 /*!
@@ -1025,9 +1075,7 @@ bool QDeclarativeGeoMap::isTiltingSupported() const
 */
 qreal QDeclarativeGeoMap::minimumTilt() const
 {
-    if (!m_map || !m_map->cameraCapabilities().supportsTilting())
-        return 0.0;
-    return m_map->cameraCapabilities().minimumTilt();
+    return m_cameraCapabilities.minimumTilt();
 }
 
 /*!
@@ -1041,11 +1089,7 @@ qreal QDeclarativeGeoMap::minimumTilt() const
 */
 qreal QDeclarativeGeoMap::maximumTilt() const
 {
-    if (!m_map)
-        return 89.0;
-    else if (!m_map->cameraCapabilities().supportsTilting())
-        return 0.0;
-    return m_map->cameraCapabilities().maximumTilt();
+    return m_cameraCapabilities.maximumTilt();
 }
 
 /*!
@@ -1716,7 +1760,7 @@ void QDeclarativeGeoMap::geometryChanged(const QRectF &newGeometry, const QRectF
     if (!m_initialized) {
         initialize();
     } else {
-        setMinimumZoomLevel(m_map->minimumZoom());
+        setMinimumZoomLevel(m_map->minimumZoom(), false);
 
         // Update the center latitudinal threshold
         double maximumCenterLatitudeAtZoom = m_map->maximumCenterLatitudeAtZoom(m_cameraData);
diff --git a/src/location/declarativemaps/qdeclarativegeomap_p.h b/src/location/declarativemaps/qdeclarativegeomap_p.h
index a7519a48..f69ca6a1 100644
--- a/src/location/declarativemaps/qdeclarativegeomap_p.h
+++ b/src/location/declarativemaps/qdeclarativegeomap_p.h
@@ -54,6 +54,7 @@
 #include <QtLocation/private/qdeclarativegeomapitemgroup_p.h>
 #include <QtLocation/qgeoserviceprovider.h>
 #include <QtLocation/private/qgeocameradata_p.h>
+#include <QtLocation/private/qgeocameracapabilities_p.h>
 #include <QtQuick/QQuickItem>
 #include <QtCore/QList>
 #include <QtCore/QPointer>
@@ -111,10 +112,10 @@ public:
     void setActiveMapType(QDeclarativeGeoMapType *mapType);
     QDeclarativeGeoMapType *activeMapType() const;
 
-    void setMinimumZoomLevel(qreal minimumZoomLevel);
+    void setMinimumZoomLevel(qreal minimumZoomLevel, bool userSet = true);
     qreal minimumZoomLevel() const;
 
-    void setMaximumZoomLevel(qreal maximumZoomLevel);
+    void setMaximumZoomLevel(qreal maximumZoomLevel, bool userSet = true);
     qreal maximumZoomLevel() const;
 
     void setZoomLevel(qreal zoomLevel);
@@ -227,6 +228,7 @@ private Q_SLOTS:
     void pluginReady();
     void onMapChildrenChanged();
     void onSupportedMapTypesChanged();
+    void onCameraCapabilitiesChanged(const QGeoCameraCapabilities &oldCameraCapabilities);
 
 private:
     void setupMapView(QDeclarativeGeoMapItemView *view);
@@ -258,6 +260,9 @@ private:
     double m_maximumViewportLatitude;
     bool m_initialized;
     QList<QDeclarativeGeoMapParameter *> m_mapParameters;
+    QGeoCameraCapabilities m_cameraCapabilities;
+    qreal m_userMinimumZoomLevel;
+    qreal m_userMaximumZoomLevel;
 
     friend class QDeclarativeGeoMapItem;
     friend class QDeclarativeGeoMapItemView;
diff --git a/src/location/maps/qgeocameracapabilities.cpp b/src/location/maps/qgeocameracapabilities.cpp
index 568476fd..6426b058 100644
--- a/src/location/maps/qgeocameracapabilities.cpp
+++ b/src/location/maps/qgeocameracapabilities.cpp
@@ -57,6 +57,8 @@ public:
 
     QGeoCameraCapabilitiesPrivate &operator = (const QGeoCameraCapabilitiesPrivate &other);
 
+    bool operator == (const QGeoCameraCapabilitiesPrivate &rhs) const;
+
     bool supportsBearing_;
     bool supportsRolling_;
     bool supportsTilting_;
@@ -125,6 +127,21 @@ QGeoCameraCapabilitiesPrivate &QGeoCameraCapabilitiesPrivate::operator = (const
     return *this;
 }
 
+bool QGeoCameraCapabilitiesPrivate::operator == (const QGeoCameraCapabilitiesPrivate &rhs) const
+{
+    return ((supportsBearing_ == rhs.supportsBearing_)
+            && (supportsRolling_ == rhs.supportsRolling_)
+            && (supportsTilting_ == rhs.supportsTilting_)
+            && (valid_ == rhs.valid_)
+            && (minZoom_ == rhs.minZoom_)
+            && (maxZoom_ == rhs.maxZoom_)
+            && (minTilt_ == rhs.minTilt_)
+            && (maxTilt_ == rhs.maxTilt_)
+            && (tileSize_ == rhs.tileSize_)
+            && (minimumFieldOfView_ == rhs.minimumFieldOfView_)
+            && (maximumFieldOfView_ == rhs.maximumFieldOfView_));
+}
+
 /*!
     \class QGeoCameraCapabilities
     \inmodule QtLocation
@@ -171,6 +188,16 @@ QGeoCameraCapabilities &QGeoCameraCapabilities::operator = (const QGeoCameraCapa
     return *this;
 }
 
+bool QGeoCameraCapabilities::operator == (const QGeoCameraCapabilities &rhs) const
+{
+    return (*(d.constData()) == *(rhs.d.constData()));
+}
+
+bool QGeoCameraCapabilities::operator != (const QGeoCameraCapabilities &other) const
+{
+    return !(operator==(other));
+}
+
 void QGeoCameraCapabilities::setTileSize(int tileSize)
 {
     if (tileSize < 1)
@@ -388,7 +415,7 @@ double QGeoCameraCapabilities::minimumFieldOfView() const
 */
 void QGeoCameraCapabilities::setMaximumFieldOfView(double maximumFieldOfView)
 {
-    d->maximumFieldOfView_ = maximumFieldOfView;
+    d->maximumFieldOfView_ = qBound(1.0, maximumFieldOfView, 179.0);
     d->valid_ = true;
 }
 
diff --git a/src/location/maps/qgeocameracapabilities_p.h b/src/location/maps/qgeocameracapabilities_p.h
index c9da53e9..099ad76d 100644
--- a/src/location/maps/qgeocameracapabilities_p.h
+++ b/src/location/maps/qgeocameracapabilities_p.h
@@ -65,6 +65,9 @@ public:
 
     QGeoCameraCapabilities &operator = (const QGeoCameraCapabilities &other);
 
+    bool operator == (const QGeoCameraCapabilities &other) const;
+    bool operator != (const QGeoCameraCapabilities &other) const;
+
     void setTileSize(int tileSize);
     int tileSize() const;
 
diff --git a/src/location/maps/qgeomap.cpp b/src/location/maps/qgeomap.cpp
index 9d3f4efa..2419b79a 100644
--- a/src/location/maps/qgeomap.cpp
+++ b/src/location/maps/qgeomap.cpp
@@ -92,6 +92,12 @@ void QGeoMap::setCameraData(const QGeoCameraData &cameraData)
     emit cameraDataChanged(d->m_cameraData);
 }
 
+void QGeoMap::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
+{
+    Q_D(QGeoMap);
+    d->setCameraCapabilities(cameraCapabilities);
+}
+
 QGeoCameraData QGeoMap::cameraData() const
 {
     Q_D(const QGeoMap);
@@ -104,6 +110,7 @@ void QGeoMap::setActiveMapType(const QGeoMapType type)
     if (type == d->m_activeMapType)
         return;
     d->m_activeMapType = type;
+    d->setCameraCapabilities(d->m_engine->cameraCapabilities(type)); // emits
     d->changeActiveMapType(type);
     emit activeMapTypeChanged();
 }
@@ -147,10 +154,7 @@ const QGeoProjection &QGeoMap::geoProjection() const
 QGeoCameraCapabilities QGeoMap::cameraCapabilities() const
 {
     Q_D(const QGeoMap);
-    if (!d->m_engine.isNull())
-        return d->m_engine->cameraCapabilities();
-    else
-        return QGeoCameraCapabilities();
+    return d->m_cameraCapabilities;
 }
 
 void QGeoMap::prefetchData()
@@ -232,6 +236,9 @@ QGeoMapPrivate::QGeoMapPrivate(QGeoMappingManagerEngine *engine, QGeoProjection
       m_engine(engine),
       m_activeMapType(QGeoMapType())
 {
+    // Setting the default camera caps without emitting anything
+    if (engine)
+        m_cameraCapabilities = m_engine->cameraCapabilities(m_activeMapType);
 }
 
 QGeoMapPrivate::~QGeoMapPrivate()
@@ -240,6 +247,21 @@ QGeoMapPrivate::~QGeoMapPrivate()
         delete m_geoProjection;
 }
 
+void QGeoMapPrivate::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
+{
+    Q_Q(QGeoMap);
+    if (m_cameraCapabilities == cameraCapabilities)
+        return;
+    QGeoCameraCapabilities oldCaps = m_cameraCapabilities;
+    m_cameraCapabilities = cameraCapabilities;
+    emit q->cameraCapabilitiesChanged(oldCaps);
+}
+
+const QGeoCameraCapabilities &QGeoMapPrivate::cameraCapabilities() const
+{
+    return m_cameraCapabilities;
+}
+
 void QGeoMapPrivate::addParameter(QGeoMapParameter *param)
 {
     Q_UNUSED(param)
diff --git a/src/location/maps/qgeomap_p.h b/src/location/maps/qgeomap_p.h
index 7e2d4bbd..bb7ade55 100644
--- a/src/location/maps/qgeomap_p.h
+++ b/src/location/maps/qgeomap_p.h
@@ -127,12 +127,14 @@ public:
 protected:
     QGeoMap(QGeoMapPrivate &dd, QObject *parent = 0);
     void setCameraData(const QGeoCameraData &cameraData);
+    void setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities);
     virtual QSGNode *updateSceneGraph(QSGNode *node, QQuickWindow *window) = 0;
 
 Q_SIGNALS:
     void cameraDataChanged(const QGeoCameraData &cameraData);
     void sgNodeChanged();
     void activeMapTypeChanged();
+    void cameraCapabilitiesChanged(const QGeoCameraCapabilities &oldCameraCapabilities);
     void copyrightsChanged(const QImage &copyrightsImage);
     void copyrightsChanged(const QString &copyrightsHtml);
     void copyrightsStyleSheetChanged(const QString &styleSheet);
diff --git a/src/location/maps/qgeomap_p_p.h b/src/location/maps/qgeomap_p_p.h
index 399fd75b..ec498484 100644
--- a/src/location/maps/qgeomap_p_p.h
+++ b/src/location/maps/qgeomap_p_p.h
@@ -51,6 +51,8 @@
 #include <QtLocation/private/qgeocameradata_p.h>
 #include <QtLocation/private/qgeomaptype_p.h>
 #include <QtLocation/private/qgeoprojection_p.h>
+#include <QtLocation/private/qgeomap_p.h>
+#include <QtLocation/private/qgeocameracapabilities_p.h>
 #include <QtCore/private/qobject_p.h>
 #include <QtCore/QSize>
 #include <QtCore/QList>
@@ -73,6 +75,8 @@ public:
     virtual ~QGeoMapPrivate();
 
     const QGeoProjection *geoProjection() const;
+    void setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities);
+    const QGeoCameraCapabilities &cameraCapabilities() const;
 protected:
     /* Hooks into the actual map implementations */
     virtual void addParameter(QGeoMapParameter *param);
@@ -94,6 +98,7 @@ protected:
     QGeoMapType m_activeMapType;
     QList<QGeoMapParameter *> m_mapParameters;
     QList<QDeclarativeGeoMapItemBase *> m_mapItems;
+    QGeoCameraCapabilities m_cameraCapabilities;
 };
 
 QT_END_NAMESPACE
diff --git a/src/location/maps/qgeomappingmanager.cpp b/src/location/maps/qgeomappingmanager.cpp
index 7d829965..cf040beb 100644
--- a/src/location/maps/qgeomappingmanager.cpp
+++ b/src/location/maps/qgeomappingmanager.cpp
@@ -128,11 +128,6 @@ int QGeoMappingManager::managerVersion() const
     return d_ptr->engine->managerVersion();
 }
 
-QGeoCameraCapabilities QGeoMappingManager::cameraCapabilities() const
-{
-    return d_ptr->engine->cameraCapabilities();
-}
-
 /*!
     Returns a new QGeoMap instance which will be managed by this manager.
 */
diff --git a/src/location/maps/qgeomappingmanager_p.h b/src/location/maps/qgeomappingmanager_p.h
index f536b15b..2f8e5283 100644
--- a/src/location/maps/qgeomappingmanager_p.h
+++ b/src/location/maps/qgeomappingmanager_p.h
@@ -52,7 +52,7 @@
 #include <QSize>
 #include <QPair>
 #include <QtLocation/private/qlocationglobal_p.h>
-#include "qgeomaptype_p.h"
+#include <QtLocation/private/qgeomaptype_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -82,8 +82,6 @@ public:
 
     bool isInitialized() const;
 
-    QGeoCameraCapabilities cameraCapabilities() const;
-
     void setLocale(const QLocale &locale);
     QLocale locale() const;
 
diff --git a/src/location/maps/qgeomappingmanagerengine.cpp b/src/location/maps/qgeomappingmanagerengine.cpp
index 5094c1b3..a385f8ce 100644
--- a/src/location/maps/qgeomappingmanagerengine.cpp
+++ b/src/location/maps/qgeomappingmanagerengine.cpp
@@ -150,8 +150,9 @@ void QGeoMappingManagerEngine::setSupportedMapTypes(const QList<QGeoMapType> &su
     emit supportedMapTypesChanged();
 }
 
-QGeoCameraCapabilities QGeoMappingManagerEngine::cameraCapabilities() const
+QGeoCameraCapabilities QGeoMappingManagerEngine::cameraCapabilities(const QGeoMapType &mapType) const
 {
+    Q_UNUSED(mapType)
     Q_D(const QGeoMappingManagerEngine);
     return d->capabilities_;
 }
diff --git a/src/location/maps/qgeomappingmanagerengine_p.h b/src/location/maps/qgeomappingmanagerengine_p.h
index 13956141..b8ebb1ec 100644
--- a/src/location/maps/qgeomappingmanagerengine_p.h
+++ b/src/location/maps/qgeomappingmanagerengine_p.h
@@ -89,7 +89,8 @@ public:
 
     QList<QGeoMapType> supportedMapTypes() const;
 
-    QGeoCameraCapabilities cameraCapabilities() const;
+    // the class is private, so this can be virtual here for now.
+    virtual QGeoCameraCapabilities cameraCapabilities(const QGeoMapType &mapType) const;
 
     void setLocale(const QLocale &locale);
     QLocale locale() const;
diff --git a/src/location/maps/qgeotiledmap.cpp b/src/location/maps/qgeotiledmap.cpp
index fc08fe62..68f150db 100644
--- a/src/location/maps/qgeotiledmap.cpp
+++ b/src/location/maps/qgeotiledmap.cpp
@@ -66,6 +66,10 @@ QGeoTiledMap::QGeoTiledMap(QGeoTiledMappingManagerEngine *engine, QObject *paren
 
     QObject::connect(engine,&QGeoTiledMappingManagerEngine::tileVersionChanged,
                      this,&QGeoTiledMap::handleTileVersionChanged);
+    QObject::connect(this, &QGeoMap::cameraCapabilitiesChanged,
+                     [d](const QGeoCameraCapabilities &oldCameraCapabilities) {
+                       d->onCameraCapabilitiesChanged(oldCameraCapabilities);
+                     });
 }
 
 QGeoTiledMap::QGeoTiledMap(QGeoTiledMapPrivate &dd, QGeoTiledMappingManagerEngine *engine, QObject *parent)
@@ -77,6 +81,10 @@ QGeoTiledMap::QGeoTiledMap(QGeoTiledMapPrivate &dd, QGeoTiledMappingManagerEngin
 
     QObject::connect(engine,&QGeoTiledMappingManagerEngine::tileVersionChanged,
                      this,&QGeoTiledMap::handleTileVersionChanged);
+    QObject::connect(this, &QGeoMap::cameraCapabilitiesChanged,
+                     [d](const QGeoCameraCapabilities &oldCameraCapabilities) {
+                       d->onCameraCapabilitiesChanged(oldCameraCapabilities);
+                     });
 }
 
 QGeoTiledMap::~QGeoTiledMap()
@@ -164,11 +172,11 @@ QGeoTiledMapPrivate::QGeoTiledMapPrivate(QGeoTiledMappingManagerEngine *engine)
       m_prefetchTiles(new QGeoCameraTiles()),
       m_mapScene(new QGeoTiledMapScene()),
       m_tileRequests(0),
-      m_maxZoomLevel(static_cast<int>(std::ceil(engine->cameraCapabilities().maximumZoomLevel()))),
-      m_minZoomLevel(static_cast<int>(std::ceil(engine->cameraCapabilities().minimumZoomLevel()))),
+      m_maxZoomLevel(static_cast<int>(std::ceil(m_cameraCapabilities.maximumZoomLevel()))),
+      m_minZoomLevel(static_cast<int>(std::ceil(m_cameraCapabilities.minimumZoomLevel()))),
       m_prefetchStyle(QGeoTiledMap::PrefetchTwoNeighbourLayers)
 {
-    int tileSize = engine->tileSize().width();
+    int tileSize = m_cameraCapabilities.tileSize();
     QString pluginString(engine->managerName() + QLatin1Char('_') + QString::number(engine->managerVersion()));
     m_visibleTiles->setTileSize(tileSize);
     m_prefetchTiles->setTileSize(tileSize);
@@ -247,6 +255,23 @@ QGeoMapType QGeoTiledMapPrivate::activeMapType()
     return m_visibleTiles->activeMapType();
 }
 
+// Called before changeCameraData
+void QGeoTiledMapPrivate::onCameraCapabilitiesChanged(const QGeoCameraCapabilities &oldCameraCapabilities)
+{
+    // Handle varying min/maxZoomLevel
+    if (oldCameraCapabilities.minimumZoomLevel() != m_cameraCapabilities.minimumZoomLevel())
+        m_minZoomLevel = static_cast<int>(std::ceil(m_cameraCapabilities.minimumZoomLevel()));
+    if (oldCameraCapabilities.maximumZoomLevel() != m_cameraCapabilities.maximumZoomLevel())
+        m_maxZoomLevel = static_cast<int>(std::ceil(m_cameraCapabilities.maximumZoomLevel()));
+
+    // Handle varying tile size
+    if (oldCameraCapabilities.tileSize() != m_cameraCapabilities.tileSize()) {
+        m_visibleTiles->setTileSize(oldCameraCapabilities.tileSize());
+        m_prefetchTiles->setTileSize(oldCameraCapabilities.tileSize());
+        m_mapScene->setTileSize(oldCameraCapabilities.tileSize());
+    }
+}
+
 void QGeoTiledMapPrivate::changeCameraData(const QGeoCameraData &cameraData)
 {
     Q_Q(QGeoTiledMap);
diff --git a/src/location/maps/qgeotiledmap_p_p.h b/src/location/maps/qgeotiledmap_p_p.h
index 7106adf3..3dc589ae 100644
--- a/src/location/maps/qgeotiledmap_p_p.h
+++ b/src/location/maps/qgeotiledmap_p_p.h
@@ -66,6 +66,7 @@ class QGeoTileRequestManager;
 class QGeoTileSpec;
 class QSGNode;
 class QQuickWindow;
+class QGeoCameraCapabilities;
 
 class Q_LOCATION_PRIVATE_EXPORT QGeoTiledMapPrivate : public QGeoMapPrivate
 {
@@ -79,6 +80,7 @@ public:
     void updateTile(const QGeoTileSpec &spec);
     void prefetchTiles();
     QGeoMapType activeMapType();
+    void onCameraCapabilitiesChanged(const QGeoCameraCapabilities &oldCameraCapabilities);
 
 protected:
     void changeViewportSize(const QSize& size) Q_DECL_OVERRIDE;