[Qt] Refactor QMapboxGL MapObserver signalsupstream/qmapboxgl-mapobserver

3 files changed, 85 insertions, 55 deletions

diff --git a/platform/qt/include/qmapboxgl.hpp b/platform/qt/include/qmapboxgl.hpp
index 00c5735a93..fe0b96696c 100644
--- a/platform/qt/include/qmapboxgl.hpp
+++ b/platform/qt/include/qmapboxgl.hpp
@@ -94,25 +94,6 @@ class Q_DECL_EXPORT QMapboxGL : public QObject
     Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
 
 public:
-    enum MapChange {
-        MapChangeRegionWillChange = 0,
-        MapChangeRegionWillChangeAnimated,
-        MapChangeRegionIsChanging,
-        MapChangeRegionDidChange,
-        MapChangeRegionDidChangeAnimated,
-        MapChangeWillStartLoadingMap,
-        MapChangeDidFinishLoadingMap,
-        MapChangeDidFailLoadingMap,
-        MapChangeWillStartRenderingFrame,
-        MapChangeDidFinishRenderingFrame,
-        MapChangeDidFinishRenderingFrameFullyRendered,
-        MapChangeWillStartRenderingMap,
-        MapChangeDidFinishRenderingMap,
-        MapChangeDidFinishRenderingMapFullyRendered,
-        MapChangeDidFinishLoadingStyle,
-        MapChangeSourceDidChange
-    };
-
     // Determines the orientation of the map.
     enum NorthOrientation {
         NorthUpwards, // Default
@@ -121,6 +102,18 @@ public:
         NorthLeftwards,
     };
 
+    // Determines whether a camera change is immediate or animated.
+    enum CameraChangeMode {
+        Immediate,
+        Animated
+    };
+
+    // Determines whether rendering tiles with complete data or not.
+    enum RenderMode {
+        Partial,
+        Full
+    };
+
     QMapboxGL(QObject* parent = 0,
               const QMapboxGLSettings& = QMapboxGLSettings(),
               const QSize& size = QSize(),
@@ -232,15 +225,29 @@ public slots:
 
 signals:
     void needsRendering();
-    void mapChanged(QMapboxGL::MapChange);
     void copyrightsChanged(const QString &copyrightsHtml);
 
+signals:
+    void cameraWillChange(QMapboxGL::CameraChangeMode);
+    void cameraIsChanging();
+    void cameraDidChange(QMapboxGL::CameraChangeMode);
+    void willStartLoadingMap();
+    void didFinishLoadingMap();
+    void didFailLoadingMap(const QString& error);
+    void willStartRenderingFrame();
+    void didFinishRenderingFrame(QMapboxGL::RenderMode);
+    void willStartRenderingMap();
+    void didFinishRenderingMap(QMapboxGL::RenderMode);
+    void didFinishLoadingStyle();
+    void sourceChanged(const QString& sourceID);
+
 private:
     Q_DISABLE_COPY(QMapboxGL)
 
     QMapboxGLPrivate *d_ptr;
 };
 
-Q_DECLARE_METATYPE(QMapboxGL::MapChange);
+Q_DECLARE_METATYPE(QMapboxGL::CameraChangeMode);
+Q_DECLARE_METATYPE(QMapboxGL::RenderMode);
 
 #endif // QMAPBOXGL_H
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index 5776502a5b..393d788644 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -41,6 +41,7 @@
 #include <QStringList>
 #include <QThreadStorage>
 
+#include <exception>
 #include <memory>
 
 using namespace QMapbox;
@@ -64,6 +65,14 @@ static_assert(mbgl::underlying_type(QMapboxGL::NorthRightwards) == mbgl::underly
 static_assert(mbgl::underlying_type(QMapboxGL::NorthDownwards) == mbgl::underlying_type(mbgl::NorthOrientation::Downwards), "error");
 static_assert(mbgl::underlying_type(QMapboxGL::NorthLeftwards) == mbgl::underlying_type(mbgl::NorthOrientation::Leftwards), "error");
 
+// mbgl::MapObserver::CameraChangeMode
+static_assert(mbgl::underlying_type(QMapboxGL::Immediate) == mbgl::underlying_type(mbgl::MapObserver::CameraChangeMode::Immediate), "error");
+static_assert(mbgl::underlying_type(QMapboxGL::Animated) == mbgl::underlying_type(mbgl::MapObserver::CameraChangeMode::Animated), "error");
+
+// mbgl::MapObserver::RenderMode
+static_assert(mbgl::underlying_type(QMapboxGL::Partial) == mbgl::underlying_type(mbgl::MapObserver::RenderMode::Partial), "error");
+static_assert(mbgl::underlying_type(QMapboxGL::Full) == mbgl::underlying_type(mbgl::MapObserver::RenderMode::Full), "error");
+
 namespace {
 
 QThreadStorage<std::shared_ptr<mbgl::util::RunLoop>> loop;
@@ -1557,14 +1566,27 @@ QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settin
         static_cast<mbgl::ConstrainMode>(settings.constrainMode()),
         static_cast<mbgl::ViewportMode>(settings.viewportMode())))
 {
-    qRegisterMetaType<QMapboxGL::MapChange>("QMapboxGL::MapChange");
+    qRegisterMetaType<QMapboxGL::CameraChangeMode>("QMapboxGL::CameraChangeMode");
+    qRegisterMetaType<QMapboxGL::RenderMode>("QMapboxGL::RenderMode");
 
     fileSourceObj->setAccessToken(settings.accessToken().toStdString());
     fileSourceObj->setAPIBaseURL(settings.apiBaseUrl().toStdString());
 
     connect(this, SIGNAL(needsRendering()), q_ptr, SIGNAL(needsRendering()), Qt::QueuedConnection);
-    connect(this, SIGNAL(mapChanged(QMapboxGL::MapChange)), q_ptr, SIGNAL(mapChanged(QMapboxGL::MapChange)), Qt::QueuedConnection);
     connect(this, SIGNAL(copyrightsChanged(QString)), q_ptr, SIGNAL(copyrightsChanged(QString)), Qt::QueuedConnection);
+
+    connect(this, SIGNAL(cameraWillChange(QMapboxGL::CameraChangeMode)), q_ptr, SIGNAL(cameraWillChange(QMapboxGL::CameraChangeMode)), Qt::QueuedConnection);
+    connect(this, SIGNAL(cameraIsChanging()), q_ptr, SIGNAL(cameraIsChanging()), Qt::QueuedConnection);
+    connect(this, SIGNAL(cameraDidChange(QMapboxGL::CameraChangeMode)), q_ptr, SIGNAL(cameraDidChange(QMapboxGL::CameraChangeMode)), Qt::QueuedConnection);
+    connect(this, SIGNAL(willStartLoadingMap()), q_ptr, SIGNAL(willStartLoadingMap()), Qt::QueuedConnection);
+    connect(this, SIGNAL(didFinishLoadingMap()), q_ptr, SIGNAL(didFinishLoadingMap()), Qt::QueuedConnection);
+    connect(this, SIGNAL(didFailLoadingMap(QString)), q_ptr, SIGNAL(didFailLoadingMap(QString)), Qt::QueuedConnection);
+    connect(this, SIGNAL(willStartRenderingFrame()), q_ptr, SIGNAL(willStartRenderingFrame()), Qt::QueuedConnection);
+    connect(this, SIGNAL(didFinishRenderingFrame(QMapboxGL::RenderMode)), q_ptr, SIGNAL(didFinishRenderingFrame(QMapboxGL::RenderMode)), Qt::QueuedConnection);
+    connect(this, SIGNAL(willStartRenderingMap()), q_ptr, SIGNAL(willStartRenderingMap()), Qt::QueuedConnection);
+    connect(this, SIGNAL(didFinishRenderingMap(QMapboxGL::RenderMode)), q_ptr, SIGNAL(didFinishRenderingMap(QMapboxGL::RenderMode)), Qt::QueuedConnection);
+    connect(this, SIGNAL(didFinishLoadingStyle()), q_ptr, SIGNAL(didFinishLoadingStyle()), Qt::QueuedConnection);
+    connect(this, SIGNAL(sourceChanged(QString)), q_ptr, SIGNAL(sourceChanged(QString)), Qt::QueuedConnection);
 }
 
 QMapboxGLPrivate::~QMapboxGLPrivate()
@@ -1597,85 +1619,73 @@ void QMapboxGLPrivate::invalidate()
 
 void QMapboxGLPrivate::onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode)
 {
-    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
-        emit mapChanged(QMapboxGL::MapChangeRegionWillChange);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeRegionWillChangeAnimated);
-    }
+    emit cameraWillChange(mode == mbgl::MapObserver::CameraChangeMode::Immediate ? QMapboxGL::Immediate : QMapboxGL::Animated);
 }
 
 void QMapboxGLPrivate::onCameraIsChanging()
 {
-    emit mapChanged(QMapboxGL::MapChangeRegionIsChanging);
+    emit cameraIsChanging();
 }
 
 void QMapboxGLPrivate::onCameraDidChange(mbgl::MapObserver::CameraChangeMode mode)
 {
-    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
-        emit mapChanged(QMapboxGL::MapChangeRegionDidChange);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeRegionDidChangeAnimated);
-    }
+    emit cameraDidChange(mode == mbgl::MapObserver::CameraChangeMode::Immediate ? QMapboxGL::Immediate : QMapboxGL::Animated);
 }
 
 void QMapboxGLPrivate::onWillStartLoadingMap()
 {
-    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
+    emit willStartLoadingMap();
 }
 
 void QMapboxGLPrivate::onDidFinishLoadingMap()
 {
-    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingMap);
+    emit didFinishLoadingMap();
 }
 
-void QMapboxGLPrivate::onDidFailLoadingMap(std::exception_ptr)
+void QMapboxGLPrivate::onDidFailLoadingMap(std::exception_ptr error)
 {
-    emit mapChanged(QMapboxGL::MapChangeDidFailLoadingMap);
+    try {
+        std::rethrow_exception(error);
+    } catch (const std::exception& ex) {
+        emit didFailLoadingMap(QString::fromStdString(ex.what()));
+    }
 }
 
 void QMapboxGLPrivate::onWillStartRenderingFrame()
 {
-    emit mapChanged(QMapboxGL::MapChangeWillStartRenderingFrame);
+    emit willStartRenderingFrame();
 }
 
 void QMapboxGLPrivate::onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode mode)
 {
-    if (mode == mbgl::MapObserver::RenderMode::Partial) {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrame);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrameFullyRendered);
-    }
+    emit didFinishRenderingFrame(mode == mbgl::MapObserver::RenderMode::Partial ? QMapboxGL::Partial : QMapboxGL::Full);
 }
 
 void QMapboxGLPrivate::onWillStartRenderingMap()
 {
-    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
+    emit willStartRenderingMap();
 }
 
 void QMapboxGLPrivate::onDidFinishRenderingMap(mbgl::MapObserver::RenderMode mode)
 {
-    if (mode == mbgl::MapObserver::RenderMode::Partial) {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMap);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMapFullyRendered);
-    }
+    emit didFinishRenderingMap(mode == mbgl::MapObserver::RenderMode::Partial ? QMapboxGL::Partial : QMapboxGL::Full);
 }
 
 void QMapboxGLPrivate::onDidFinishLoadingStyle()
 {
-    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingStyle);
+    emit didFinishLoadingStyle();
 }
 
-void QMapboxGLPrivate::onSourceChanged(mbgl::style::Source&)
+void QMapboxGLPrivate::onSourceChanged(mbgl::style::Source& source_)
 {
     std::string attribution;
-    for (const auto& source : mapObj->getSources()) {
+    for (const auto& source: mapObj->getSources()) {
         // Avoid duplicates by using the most complete attribution HTML snippet.
         if (source->getAttribution() && (attribution.size() < source->getAttribution()->size()))
             attribution = *source->getAttribution();
     }
     emit copyrightsChanged(QString::fromStdString(attribution));
-    emit mapChanged(QMapboxGL::MapChangeSourceDidChange);
+    emit sourceChanged(QString::fromStdString(source_.getID()));
 }
 
 /*!
diff --git a/platform/qt/src/qmapboxgl_p.hpp b/platform/qt/src/qmapboxgl_p.hpp
index 464b66bd73..11d14c3caf 100644
--- a/platform/qt/src/qmapboxgl_p.hpp
+++ b/platform/qt/src/qmapboxgl_p.hpp
@@ -66,6 +66,19 @@ public slots:
 
 signals:
     void needsRendering();
-    void mapChanged(QMapboxGL::MapChange);
     void copyrightsChanged(const QString &copyrightsHtml);
+
+signals:
+    void cameraWillChange(QMapboxGL::CameraChangeMode);
+    void cameraIsChanging();
+    void cameraDidChange(QMapboxGL::CameraChangeMode);
+    void willStartLoadingMap();
+    void didFinishLoadingMap();
+    void didFailLoadingMap(const QString& error);
+    void willStartRenderingFrame();
+    void didFinishRenderingFrame(QMapboxGL::RenderMode);
+    void willStartRenderingMap();
+    void didFinishRenderingMap(QMapboxGL::RenderMode);
+    void didFinishLoadingStyle();
+    void sourceChanged(const QString& sourceID);
 };