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>

4 files changed, 227 insertions, 10 deletions

diff --git a/tests/auto/declarative_ui/tst_map.qml b/tests/auto/declarative_ui/tst_map.qml
index ab1ddd8c..004e3b10 100644
--- a/tests/auto/declarative_ui/tst_map.qml
+++ b/tests/auto/declarative_ui/tst_map.qml
@@ -260,6 +260,47 @@ Item {
             compare(map.maximumZoomLevel, 20)
         }
 
+        function test_tilt_limits()
+        {
+            // Tilt limits are read only
+            map.tilt = 0
+
+            //initial plugin values
+            compare(map.minimumTilt, 0)
+            compare(map.maximumTilt, 60)
+
+            map.tilt = 18
+            compare(map.tilt, 18)
+
+            map.tilt = -2
+            compare(map.tilt, 0)
+
+            map.tilt = 2
+            compare(map.tilt, 2)
+
+            map.tilt = 62
+            compare(map.tilt, 60)
+
+            map.tilt = 0
+            compare(map.tilt, 0)
+        }
+
+        function test_fov_limits()
+        {
+            // Tilt limits are read only
+            map.fieldOfView = 45
+
+            //initial plugin values
+            compare(map.fieldOfView, 45)
+            compare(map.fieldOfView, 45)
+
+            map.fieldOfView = 18
+            compare(map.fieldOfView, 45)
+
+            map.fieldOfView = 62
+            compare(map.fieldOfView, 45)
+        }
+
         function test_zoom()
         {
             wait(1000)
diff --git a/tests/auto/declarative_ui/tst_map_maptype.qml b/tests/auto/declarative_ui/tst_map_maptype.qml
index fa056c44..17e958d5 100644
--- a/tests/auto/declarative_ui/tst_map_maptype.qml
+++ b/tests/auto/declarative_ui/tst_map_maptype.qml
@@ -40,6 +40,12 @@ Item{
     Map { id: map; anchors.fill: parent }
     SignalSpy { id: supportedMapTypesSpy; target: map; signalName: "supportedMapTypesChanged" }
     SignalSpy { id: activeMapTypeChangedSpy; target: map; signalName: "activeMapTypeChanged" }
+    SignalSpy { id: minimumZoomLevelChangedSpy; target: map; signalName: "minimumZoomLevelChanged" }
+    SignalSpy { id: maximumZoomLevelChangedSpy; target: map; signalName: "maximumZoomLevelChanged" }
+    SignalSpy { id: minimumTiltChangedSpy; target: map; signalName: "minimumTiltChanged" }
+    SignalSpy { id: maximumTiltChangedSpy; target: map; signalName: "maximumTiltChanged" }
+    SignalSpy { id: minimumFieldOfViewChangedSpy; target: map; signalName: "minimumFieldOfViewChanged" }
+    SignalSpy { id: maximumFieldOfViewChangedSpy; target: map; signalName: "maximumFieldOfViewChanged" }
 
     TestCase {
         id: testCase
@@ -52,7 +58,7 @@ Item{
             compare(map.activeMapType.style, MapType.NoMap)
             map.plugin = testPlugin
             tryCompare(supportedMapTypesSpy, "count", 1)
-            compare(map.supportedMapTypes.length,3)
+            compare(map.supportedMapTypes.length, 4)
             compare(map.supportedMapTypes[0].style, MapType.StreetMap)
             compare(map.supportedMapTypes[0].name, "StreetMap")
             compare(map.supportedMapTypes[0].description, "StreetMap")
@@ -62,6 +68,9 @@ Item{
             compare(map.supportedMapTypes[2].style, MapType.CycleMap)
             compare(map.supportedMapTypes[2].name, "CycleMap")
             compare(map.supportedMapTypes[2].description, "CycleMap")
+            compare(map.supportedMapTypes[3].style, MapType.CustomMap)
+            compare(map.supportedMapTypes[3].name, "AlternateCameraCapabilities")
+            compare(map.supportedMapTypes[3].description, "AlternateCameraCapabilities")
             //default
             compare(map.activeMapType.style, MapType.StreetMap)
         }
@@ -87,6 +96,89 @@ Item{
             tryCompare(activeMapTypeChangedSpy, "count", 2)
             compare(map.supportedMapTypes[2].name, map.activeMapType.name)
             compare(map.supportedMapTypes[2].style, map.activeMapType.style)
+
+            map.activeMapType = map.supportedMapTypes[3]
+            tryCompare(activeMapTypeChangedSpy, "count", 3)
+            compare(map.supportedMapTypes[3].name, map.activeMapType.name)
+            compare(map.supportedMapTypes[3].style, map.activeMapType.style)
+        }
+
+        function test_maptype_capabilities()
+        {
+            minimumZoomLevelChangedSpy.clear();
+            maximumZoomLevelChangedSpy.clear();
+            minimumTiltChangedSpy.clear();
+            maximumTiltChangedSpy.clear();
+            minimumFieldOfViewChangedSpy.clear();
+            maximumFieldOfViewChangedSpy.clear();
+
+            map.activeMapType = map.supportedMapTypes[0]
+
+            compare(map.minimumZoomLevel, 0)
+            compare(map.maximumZoomLevel, 20)
+            compare(map.minimumTilt, 0)
+            compare(map.maximumTilt, 60)
+            compare(map.minimumFieldOfView, 45)
+            compare(map.maximumFieldOfView, 45)
+
+            tryCompare(minimumZoomLevelChangedSpy, "count", 0)
+            tryCompare(maximumZoomLevelChangedSpy, "count", 0)
+            tryCompare(minimumTiltChangedSpy, "count", 0)
+            tryCompare(maximumTiltChangedSpy, "count", 0)
+            tryCompare(minimumFieldOfViewChangedSpy, "count", 0)
+            tryCompare(maximumFieldOfViewChangedSpy, "count", 0)
+
+
+            map.activeMapType = map.supportedMapTypes[1]
+
+            compare(map.minimumZoomLevel, 0)
+            compare(map.maximumZoomLevel, 20)
+            compare(map.minimumTilt, 0)
+            compare(map.maximumTilt, 60)
+            compare(map.minimumFieldOfView, 45)
+            compare(map.maximumFieldOfView, 45)
+
+            tryCompare(minimumZoomLevelChangedSpy, "count", 0)
+            tryCompare(maximumZoomLevelChangedSpy, "count", 0)
+            tryCompare(minimumTiltChangedSpy, "count", 0)
+            tryCompare(maximumTiltChangedSpy, "count", 0)
+            tryCompare(minimumFieldOfViewChangedSpy, "count", 0)
+            tryCompare(maximumFieldOfViewChangedSpy, "count", 0)
+
+
+            map.activeMapType = map.supportedMapTypes[3]
+
+            compare(map.minimumZoomLevel, 0)
+            compare(map.maximumZoomLevel, 19)
+            compare(map.minimumTilt, 0)
+            compare(map.maximumTilt, 80)
+            compare(map.minimumFieldOfView, 1)
+            compare(map.maximumFieldOfView, 179)
+
+            tryCompare(minimumZoomLevelChangedSpy, "count", 0)
+            tryCompare(maximumZoomLevelChangedSpy, "count", 1)
+            tryCompare(minimumTiltChangedSpy, "count", 0)
+            tryCompare(maximumTiltChangedSpy, "count", 1)
+            tryCompare(minimumFieldOfViewChangedSpy, "count", 1)
+            tryCompare(maximumFieldOfViewChangedSpy, "count", 1)
+
+
+            map.activeMapType = map.supportedMapTypes[0]
+
+            compare(map.minimumZoomLevel, 0)
+            compare(map.maximumZoomLevel, 20)
+            compare(map.minimumTilt, 0)
+            compare(map.maximumTilt, 60)
+            compare(map.minimumFieldOfView, 45)
+            compare(map.maximumFieldOfView, 45)
+
+            tryCompare(minimumZoomLevelChangedSpy, "count", 0)
+            tryCompare(maximumZoomLevelChangedSpy, "count", 2)
+            tryCompare(minimumTiltChangedSpy, "count", 0)
+            tryCompare(maximumTiltChangedSpy, "count", 2)
+            tryCompare(minimumFieldOfViewChangedSpy, "count", 2)
+            tryCompare(maximumFieldOfViewChangedSpy, "count", 2)
+
         }
     }
 }
diff --git a/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h b/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h
index 015a203a..df729392 100644
--- a/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h
+++ b/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h
@@ -66,6 +66,7 @@ public:
         mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("StreetMap"), tr("StreetMap"), false, false, 1);
         mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("SatelliteMapDay"), tr("SatelliteMapDay"), false, false, 2);
         mapTypes << QGeoMapType(QGeoMapType::CycleMap, tr("CycleMap"), tr("CycleMap"), false, false, 3);
+        mapTypes << QGeoMapType(QGeoMapType::CustomMap, tr("AlternateCameraCapabilities"), tr("AlternateCameraCapabilities"), false, false, 4);
         setSupportedMapTypes(mapTypes);
 
         QGeoTileFetcherTest *fetcher = new QGeoTileFetcherTest(this);
@@ -90,6 +91,27 @@ public:
         return new QGeoTiledMapTest(this);
     }
 
+    QGeoCameraCapabilities cameraCapabilities(const QGeoMapType &mapType) const Q_DECL_OVERRIDE
+    {
+        switch (mapType.mapId()) {
+        case 4:
+        {
+            QGeoCameraCapabilities capabilities;
+            capabilities.setMinimumZoomLevel(0.0);
+            capabilities.setMaximumZoomLevel(19.0);
+            capabilities.setSupportsBearing(true);
+            capabilities.setSupportsTilting(true);
+            capabilities.setMinimumTilt(0);
+            capabilities.setMaximumTilt(80);
+            capabilities.setMinimumFieldOfView(1);
+            capabilities.setMaximumFieldOfView(179);
+            return capabilities;
+        }
+        default:
+            return QGeoMappingManagerEngine::cameraCapabilities(mapType);
+        }
+    }
+
 };
 
 #endif
diff --git a/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp
index 09d7293b..06d85e1e 100644
--- a/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp
+++ b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp
@@ -54,6 +54,8 @@ private Q_SLOTS:
     void supportsTiltingTest();
     void minimumTiltTest();
     void maximumTiltTest();
+    void minimumFieldOfViewTest();
+    void maximumFieldOfViewTest();
     void operatorsTest_data();
     void operatorsTest();
     void isValidTest();
@@ -68,12 +70,14 @@ void tst_QGeoCameraCapabilities::populateGeoCameraCapabilitiesData(){
     QTest::addColumn<double>("maximumZoomLevel");
     QTest::addColumn<double>("minimumTilt");
     QTest::addColumn<double>("maximumTilt");
+    QTest::addColumn<double>("minimumFieldOfView");
+    QTest::addColumn<double>("maximumFieldOfView");
     QTest::addColumn<bool>("bearingSupport");
     QTest::addColumn<bool>("rollingSupport");
     QTest::addColumn<bool>("tiltingSupport");
-    QTest::newRow("zeros") << 0.0 << 0.0 << 0.0 << 0.0 << false << false << false;
-    QTest::newRow("valid") << 1.0 << 2.0 << 0.5 << 1.5 << true << true << true;
-    QTest::newRow("negative values") << 0.0 << 0.5 << -0.5 << -0.1 << true << true << true;
+    QTest::newRow("zeros") << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << false << false << false;
+    QTest::newRow("valid") << 1.0 << 2.0 << 0.5 << 1.5 << 1.0 << 179.0 << true << true << true;
+    QTest::newRow("negative values") << 0.0 << 0.5 << -0.5 << -0.1 << -20.0 << -30.0 << true << true << true;
 }
 
 void tst_QGeoCameraCapabilities::constructorTest_data(){
@@ -86,10 +90,15 @@ void tst_QGeoCameraCapabilities::constructorTest()
     QFETCH(double, maximumZoomLevel);
     QFETCH(double, minimumTilt);
     QFETCH(double, maximumTilt);
+    QFETCH(double, minimumFieldOfView);
+    QFETCH(double, maximumFieldOfView);
     QFETCH(bool, bearingSupport);
     QFETCH(bool, rollingSupport);
     QFETCH(bool, tiltingSupport);
 
+    minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0);
+    maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0);
+
     // contructor test with default values
     QGeoCameraCapabilities cameraCapabilities;
     QGeoCameraCapabilities cameraCapabilities2(cameraCapabilities);
@@ -100,12 +109,16 @@ void tst_QGeoCameraCapabilities::constructorTest()
     QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support");
     QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt());
     QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt());
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView());
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView());
 
     // constructor test after setting values
     cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel);
     cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel);
     cameraCapabilities.setMinimumTilt(minimumTilt);
     cameraCapabilities.setMaximumTilt(maximumTilt);
+    cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView);
+    cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView);
     cameraCapabilities.setSupportsBearing(bearingSupport);
     cameraCapabilities.setSupportsRolling(rollingSupport);
     cameraCapabilities.setSupportsTilting(tiltingSupport);
@@ -116,6 +129,8 @@ void tst_QGeoCameraCapabilities::constructorTest()
     QCOMPARE(cameraCapabilities3.maximumZoomLevel(), maximumZoomLevel);
     QCOMPARE(cameraCapabilities3.minimumTilt(), minimumTilt);
     QCOMPARE(cameraCapabilities3.maximumTilt(), maximumTilt);
+    QCOMPARE(cameraCapabilities3.minimumFieldOfView(), minimumFieldOfView);
+    QCOMPARE(cameraCapabilities3.maximumFieldOfView(), maximumFieldOfView);
     QVERIFY2(cameraCapabilities3.supportsBearing() == bearingSupport, "Copy constructor failed for bearing support");
     QVERIFY2(cameraCapabilities3.supportsRolling() == rollingSupport, "Copy constructor failed for rolling support ");
     QVERIFY2(cameraCapabilities3.supportsTilting() == tiltingSupport, "Copy constructor failed for tilting support");
@@ -127,6 +142,8 @@ void tst_QGeoCameraCapabilities::constructorTest()
     QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities3.supportsTilting(), "Copy constructor failed for tilting support");
     QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities3.minimumTilt());
     QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities3.maximumTilt());
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities3.minimumFieldOfView());
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities3.maximumFieldOfView());
 }
 
 void tst_QGeoCameraCapabilities::minimumZoomLevelTest()
@@ -213,6 +230,40 @@ void tst_QGeoCameraCapabilities::maximumTiltTest(){
     QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5);
 }
 
+void tst_QGeoCameraCapabilities::minimumFieldOfViewTest()
+{
+    QGeoCameraCapabilities cameraCapabilities;
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 45.0); // min/max default to 45
+    cameraCapabilities.setMinimumFieldOfView(1.5);
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.5);
+    cameraCapabilities.setMinimumFieldOfView(-1.5);
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.0);
+    cameraCapabilities.setMinimumFieldOfView(245.5);
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 179.0);
+
+    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
+    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0);
+    cameraCapabilities.setMinimumFieldOfView(2.5);
+    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0);
+}
+
+void tst_QGeoCameraCapabilities::maximumFieldOfViewTest()
+{
+    QGeoCameraCapabilities cameraCapabilities;
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 45.0); // min/max default to 45
+    cameraCapabilities.setMaximumFieldOfView(1.5);
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.5);
+    cameraCapabilities.setMaximumFieldOfView(-1.5);
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.0);
+    cameraCapabilities.setMaximumFieldOfView(245.5);
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 179.0);
+
+    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
+    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0);
+    cameraCapabilities.setMaximumFieldOfView(2.5);
+    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0);
+}
+
 void tst_QGeoCameraCapabilities::operatorsTest_data(){
     populateGeoCameraCapabilitiesData();
 }
@@ -223,15 +274,22 @@ void tst_QGeoCameraCapabilities::operatorsTest(){
     QFETCH(double, maximumZoomLevel);
     QFETCH(double, minimumTilt);
     QFETCH(double, maximumTilt);
+    QFETCH(double, minimumFieldOfView);
+    QFETCH(double, maximumFieldOfView);
     QFETCH(bool, bearingSupport);
     QFETCH(bool, rollingSupport);
     QFETCH(bool, tiltingSupport);
 
+    minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0);
+    maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0);
+
     QGeoCameraCapabilities cameraCapabilities;
     cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel);
     cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel);
     cameraCapabilities.setMinimumTilt(minimumTilt);
     cameraCapabilities.setMaximumTilt(maximumTilt);
+    cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView);
+    cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView);
     cameraCapabilities.setSupportsBearing(bearingSupport);
     cameraCapabilities.setSupportsRolling(rollingSupport);
     cameraCapabilities.setSupportsTilting(tiltingSupport);
@@ -242,17 +300,21 @@ void tst_QGeoCameraCapabilities::operatorsTest(){
     QCOMPARE(cameraCapabilities2.maximumZoomLevel(), maximumZoomLevel);
     QCOMPARE(cameraCapabilities2.minimumTilt(), minimumTilt);
     QCOMPARE(cameraCapabilities2.maximumTilt(), maximumTilt);
-    QVERIFY2(cameraCapabilities2.supportsBearing() == bearingSupport, "Copy constructor failed for bearing support");
-    QVERIFY2(cameraCapabilities2.supportsRolling() == rollingSupport, "Copy constructor failed for rolling support ");
-    QVERIFY2(cameraCapabilities2.supportsTilting() == tiltingSupport, "Copy constructor failed for tilting support");
+    QVERIFY2(cameraCapabilities2.supportsBearing() == bearingSupport, "Assignment operator failed for bearing support");
+    QVERIFY2(cameraCapabilities2.supportsRolling() == rollingSupport, "Assignment operator failed for rolling support ");
+    QVERIFY2(cameraCapabilities2.supportsTilting() == tiltingSupport, "Assignment operator failed for tilting support");
+    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), minimumFieldOfView);
+    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), maximumFieldOfView);
     // verify that values have not changed after a constructor copy
     QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities2.minimumZoomLevel());
     QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities2.maximumZoomLevel());
-    QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Copy constructor failed for bearing support");
-    QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Copy constructor failed for rolling support ");
-    QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support");
+    QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Assignment operator failed for bearing support");
+    QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Assignment operator failed for rolling support ");
+    QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Assignment operator failed for tilting support");
     QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt());
     QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt());
+    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView());
+    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView());
 }
 
 void tst_QGeoCameraCapabilities::isValidTest(){