add TileLoaded and TileUnloading events to MapboxMap class, along with LoadViewStarting and LoadViewCompleted events

Author: brnkhy

Runtime/Mapbox/BaseModule/Data/Interfaces/IMapVisualizer.cs

@@ -10,10 +10,14 @@ namespace Mapbox.BaseModule.Data.Interfaces
     public interface IMapVisualizer
     {
         public void Load(TileCover tileCover);
+        public void LoadSnapshot(TileCover tileCover);
         IEnumerator Initialize();
         IEnumerator LoadTileCoverToMemory(TileCover tileCover);
         void OnDestroy();
         Dictionary<UnwrappedTileId, UnityMapTile> ActiveTiles { get; }
         bool TryGetLayerModule<T>(Type type, out T layerModule) where T : ILayerModule;
+
+        event Action<UnityMapTile> TileLoaded;
+        event Action<UnityMapTile> TileUnloading;
     }
 }

Runtime/Mapbox/BaseModule/Map/MapboxMap.cs

@@ -35,6 +35,9 @@ public IEnumerator Initialize()
 
             Status = InitializationStatus.Initializing;
             yield return MapVisualizer.Initialize();
+            MapVisualizer.TileLoaded += tile => { TileLoaded(tile); };
+            MapVisualizer.TileUnloading += tile => { TileUnloading(tile); };
+            
             Status = InitializationStatus.Initialized;
             Initialized();
 
@@ -52,9 +55,12 @@ public void LoadMapView(Action callback)
             LoadViewStarting();
             Runnable.Instance.StartCoroutine(LoadMapViewCoroutine(() =>
             {
-                Status = InitializationStatus.ReadyForUpdates;
+                MapService.TileCover(MapInformation, TileCover);
+                MapVisualizer.LoadSnapshot(TileCover);
+                
                 callback?.Invoke();
                 LoadViewCompleted();
+                Status = InitializationStatus.ReadyForUpdates;
             }));
         }
 
@@ -65,11 +71,15 @@ public void LoadMapView(Action callback, LatitudeLongitude coordinates)
             MapInformation.SetInformation(coordinates);
             Runnable.Instance.StartCoroutine(LoadMapViewCoroutine(() =>
             {
-                callback();
+                MapService.TileCover(MapInformation, TileCover);
+                MapVisualizer.LoadSnapshot(TileCover);
+                
+                callback?.Invoke();
+                LoadViewCompleted();
                 Status = InitializationStatus.ReadyForUpdates;
             }));
         }
-
+  
         public IEnumerator LoadMapViewCoroutine(Action callback)
         {
             var tileCover = new TileCover();
@@ -83,17 +93,19 @@ public void ChangeView(LatitudeLongitude? latlng = null, float? zoom = null, flo
             MapInformation.SetInformation(latlng, zoom, pitch, bearing);
         }
 
-        public Action Initialized = () => {};
-        public Action LoadViewStarting = () => { };
-        public Action LoadViewCompleted = () => { };
-        
         public void OnDestroy()
         {
             MapVisualizer?.OnDestroy();
             MapService.OnDestroy();
         }
 
         public void UpdateTileCover() => MapService.TileCover(MapInformation, TileCover);
+        
+        public Action Initialized = () => {};
+        public Action LoadViewStarting = () => { };
+        public Action LoadViewCompleted = () => { };
+        public Action<UnityMapTile> TileLoaded = (tile) => { };
+        public Action<UnityMapTile> TileUnloading = (tile) => { };
     }
 }
 

Runtime/Mapbox/BaseModule/Map/MapboxMapVisualizer.cs

@@ -73,14 +73,7 @@ public virtual void Load(TileCover tileCover)
                 {
                     if (unityMapTile.IsTemporary)
                     {
-                        var tileFinished = true;
-                        foreach (var module in LayerModules)
-                        {
-                            var moduleFinished = module.LoadInstant(unityMapTile);
-                            tileFinished &= moduleFinished;
-                            if (!moduleFinished) break;
-                        }
-                        if (tileFinished) unityMapTile.IsTemporary = false;
+                        FinalizeTempTile(unityMapTile);
                     }
 
                     ShowTile(unityMapTile);
@@ -109,9 +102,10 @@ public virtual void Load(TileCover tileCover)
 
             foreach (var tileId in _toRemove)
             {
-                if (ActiveTiles.ContainsKey(tileId))
+                if (ActiveTiles.TryGetValue(tileId, out var tile))
                 {
-                    PoolTile(ActiveTiles[tileId]);
+                    TileUnloading(tile);
+                    PoolTile(tile);
                 }
                 else
                 {
@@ -125,6 +119,30 @@ public virtual void Load(TileCover tileCover)
             }
         }
 
+        /// <summary>
+        /// Minimal function that'll try to load view with whatever data is available.
+        /// It will not unload any tiles, it will not trigger any data fetching.
+        /// It'll only organize and use data already in memory.
+        /// If resources required for the requested tile aren't ready, it'll use whatever available
+        /// and create a "temporary tile".
+        /// </summary>
+        /// <param name="tileCover"></param>
+        public void LoadSnapshot(TileCover tileCover)
+        {
+            foreach (var tileId in tileCover.Tiles)
+            {
+                if (CreateTileInstant(tileId, out var unityMapTile))
+                {
+                    
+                }
+                else
+                {
+                    CreateTempTile(tileId, out unityMapTile);
+                }
+                ShowTile(unityMapTile);
+            }
+        }
+
         public void OnDestroy()
         {
             foreach (var layerModule in LayerModules)
@@ -210,13 +228,9 @@ protected void PoolTile(UnityMapTile tile)
 
         protected void CreateTempTile(UnwrappedTileId tileId, out UnityMapTile tile)
         {
-            var rectd = Conversions.TileBoundsInUnitySpace(tileId, _mapInformation.CenterMercator, _mapInformation.Scale);
-            tile = null;
-            tile = _tileCreator.GetTile();
-            tile.transform.position = new Vector3((float) rectd.Center.x, 0, (float) rectd.Center.y);
-            tile.transform.localScale = Vector3.one * (float) rectd.Size.x;
-            tile.Initialize(tileId, (float) rectd.Size.x * _mapInformation.Scale);
-            
+            //we need to do positioning and scaling before mesh gen for now
+            GetMapTile(tileId, out tile);
+
             foreach (var module in LayerModules)
             {
                 module.LoadTempTile(tile);
@@ -227,31 +241,46 @@ protected void CreateTempTile(UnwrappedTileId tileId, out UnityMapTile tile)
         }
 
         protected bool CreateTileInstant(UnwrappedTileId tileId, out UnityMapTile tile)
+        {
+            //we need to do positioning and scaling before mesh gen for now
+            GetMapTile(tileId, out tile);
+
+            var result = FinalizeTempTile(tile);
+            
+            //couldn't create the tile
+            if (!result) PoolTile(tile);
+
+            return result;
+        }
+
+        protected void GetMapTile(UnwrappedTileId tileId, out UnityMapTile tile)
         {
             var rectd = Conversions.TileBoundsInUnitySpace(tileId, _mapInformation.CenterMercator, _mapInformation.Scale);
             tile = null;
             tile = _tileCreator.GetTile();
             tile.transform.position = new Vector3((float) rectd.Center.x, 0, (float) rectd.Center.y);
             tile.transform.localScale = Vector3.one * (float) rectd.Size.x;
-            tile.Initialize(tileId, (float) rectd.Size.x * _mapInformation.Scale); 
-            
-            var loaded = true;
+            tile.Initialize(tileId, (float) rectd.Size.x * _mapInformation.Scale);
+        }
+        
+        protected bool FinalizeTempTile(UnityMapTile unityMapTile)
+        {
+            var tileFinished = true;
             foreach (var module in LayerModules)
             {
-                var moduleFinished = module.LoadInstant(tile);
-                loaded &= moduleFinished;
+                var moduleFinished = module.LoadInstant(unityMapTile);
+                tileFinished &= moduleFinished;
+                if (!moduleFinished) break;
             }
 
-            if (!loaded)
+            if (tileFinished)
             {
-                PoolTile(tile);
-                return false;
+                unityMapTile.IsTemporary = false;
+                ActiveTiles.TryAdd(unityMapTile.UnwrappedTileId, unityMapTile);
+                TileLoaded(unityMapTile);
             }
-            
-            tile.IsTemporary = false;
-            ActiveTiles.Add(tileId, tile);
 
-            return true;
+            return tileFinished;
         }
 
         protected void RepositionAllTiles(IMapInformation mapInformation)
@@ -266,5 +295,8 @@ protected void RepositionAllTiles(IMapInformation mapInformation)
                 module.UpdatePositioning(mapInformation);
             }
         }
+        
+        public event Action<UnityMapTile> TileLoaded = (tile) => { };
+        public event Action<UnityMapTile> TileUnloading = (tile) => { };
     }
 }