Rationalize *RenderingMap notifications

include/mbgl/ios/MGLMapView.h

@@ -418,6 +418,12 @@ IB_DESIGNABLE
 // TODO
 - (void)mapViewDidFinishRenderingMap:(MGLMapView *)mapView fullyRendered:(BOOL)fullyRendered;
 
+// TODO
+- (void)mapViewWillStartRenderingFrame:(MGLMapView *)mapView;
+
+// TODO
+- (void)mapViewDidFinishRenderingFrame:(MGLMapView *)mapView fullyRendered:(BOOL)fullyRendered;
+
 #pragma mark - Tracking the User Location
 
 /** @name Tracking the User Location */

include/mbgl/map/map.hpp

@@ -156,9 +156,18 @@ public:
     bool isFullyLoaded() const;
 
 private:
+    View& view;
     const std::unique_ptr<Transform> transform;
     const std::unique_ptr<MapData> data;
     const std::unique_ptr<util::Thread<MapContext>> context;
+
+    enum class RenderState {
+        never,
+        partial,
+        fully
+    };
+
+    RenderState renderState = RenderState::never;
     bool paused = false;
 };
 

include/mbgl/map/view.hpp

@@ -20,9 +20,12 @@ enum MapChange : uint8_t {
     MapChangeWillStartLoadingMap = 5,
     MapChangeDidFinishLoadingMap = 6,
     MapChangeDidFailLoadingMap = 7,
-    MapChangeWillStartRenderingMap = 8,
-    MapChangeDidFinishRenderingMap = 9,
-    MapChangeDidFinishRenderingMapFullyRendered = 10
+    MapChangeWillStartRenderingFrame = 8,
+    MapChangeDidFinishRenderingFrame = 9,
+    MapChangeDidFinishRenderingFrameFullyRendered = 10,
+    MapChangeWillStartRenderingMap = 11,
+    MapChangeDidFinishRenderingMap = 12,
+    MapChangeDidFinishRenderingMapFullyRendered = 13,
 };
 
 class View {

ios/benchmark/MBXBenchViewController.mm

@@ -88,7 +88,7 @@ static const int benchmarkDuration = 200; // frames
     }
 }
 
-- (void)mapViewDidFinishRenderingMap:(MGLMapView *)mapView fullyRendered:(__unused BOOL)fullyRendered
+- (void)mapViewDidFinishRenderingFrame:(MGLMapView *)mapView fullyRendered:(__unused BOOL)fullyRendered
 {
     if (state == State::Benchmarking)
     {

platform/ios/MGLMapView.mm

@@ -669,8 +669,6 @@ std::chrono::steady_clock::duration secondsAsDuration(float duration)
 {
     if ( ! self.isDormant)
     {
-        [self notifyMapChange:@(mbgl::MapChangeWillStartRenderingMap)];
-
         _mbglMap->resize(rect.size.width, rect.size.height, view.contentScaleFactor);
 
         CGFloat zoomFactor   = _mbglMap->getMaxZoom() - _mbglMap->getMinZoom() + 1;
@@ -684,8 +682,6 @@ std::chrono::steady_clock::duration secondsAsDuration(float duration)
         _mbglMap->setSourceTileCacheSize(cacheSize);
 
         _mbglMap->renderSync();
-
-        [self notifyMapChange:@(mbgl::MapChangeDidFinishRenderingMap)];
     }
 }
 
@@ -2561,18 +2557,28 @@ CLLocationCoordinate2D MGLLocationCoordinate2DFromLatLng(mbgl::LatLng latLng)
             break;
         }
         case mbgl::MapChangeDidFinishRenderingMap:
-        {
-            if ([self.delegate respondsToSelector:@selector(mapViewDidFinishRenderingMap:fullyRendered:)])
-            {
-                [self.delegate mapViewDidFinishRenderingMap:self fullyRendered:NO];
-            }
-            break;
-        }
         case mbgl::MapChangeDidFinishRenderingMapFullyRendered:
         {
             if ([self.delegate respondsToSelector:@selector(mapViewDidFinishRenderingMap:fullyRendered:)])
             {
-                [self.delegate mapViewDidFinishRenderingMap:self fullyRendered:YES];
+                [self.delegate mapViewDidFinishRenderingMap:self fullyRendered:(change == mbgl::MapChangeDidFinishRenderingMapFullyRendered)];
+            }
+            break;
+        }
+        case mbgl::MapChangeWillStartRenderingFrame:
+        {
+            if ([self.delegate respondsToSelector:@selector(mapViewWillStartRenderingFrame:)])
+            {
+                [self.delegate mapViewWillStartRenderingFrame:self];
+            }
+            break;
+        }
+        case mbgl::MapChangeDidFinishRenderingFrame:
+        case mbgl::MapChangeDidFinishRenderingFrameFullyRendered:
+        {
+            if ([self.delegate respondsToSelector:@selector(mapViewDidFinishRenderingFrame:fullyRendered:)])
+            {
+                [self.delegate mapViewDidFinishRenderingFrame:self fullyRendered:(change == mbgl::MapChangeDidFinishRenderingFrameFullyRendered)];
             }
             break;
         }

src/mbgl/map/map.cpp

@@ -12,8 +12,9 @@
 
 namespace mbgl {
 
-Map::Map(View& view, FileSource& fileSource, MapMode mode)
-    : transform(std::make_unique<Transform>(view)),
+Map::Map(View& view_, FileSource& fileSource, MapMode mode)
+    : view(view_),
+      transform(std::make_unique<Transform>(view)),
       data(std::make_unique<MapData>(mode)),
       context(std::make_unique<util::Thread<MapContext>>(util::ThreadContext{"Map", util::ThreadType::Map, util::ThreadPriority::Regular}, view, fileSource, *data))
 {
@@ -46,9 +47,26 @@ void Map::renderStill(StillImageCallback callback) {
 }
 
 void Map::renderSync() {
+    if (renderState == RenderState::never) {
+        view.notifyMapChange(MapChangeWillStartRenderingMap);
+    }
+
+    view.notifyMapChange(MapChangeWillStartRenderingFrame);
+
     MapContext::RenderResult result =
         context->invokeSync<MapContext::RenderResult>(&MapContext::renderSync, transform->getState());
 
+    view.notifyMapChange(result.fullyLoaded ?
+        MapChangeDidFinishRenderingFrameFullyRendered :
+        MapChangeDidFinishRenderingFrame);
+
+    if (!result.fullyLoaded) {
+        renderState = RenderState::partial;
+    } else if (renderState != RenderState::fully) {
+        renderState = RenderState::fully;
+        view.notifyMapChange(MapChangeDidFinishRenderingMapFullyRendered);
+    }
+
     if (transform->needsTransition()) {
         update(Update(transform->updateTransitions(Clock::now())));
     } else if (result.needsRerender) {