B4A Library GoogleMapsExtras

Sub Process_Globals
    Private RuntimePermissions1 As RuntimePermissions
End Sub

Sub Globals
    Private GoogleMap1 As GoogleMap
    Private GoogleMapsExtras1 As GoogleMapsExtras
    Private MapFragment1 As MapFragment
End Sub

Sub Activity_Create(FirstTime As Boolean)
    Activity.LoadLayout("Main")
End Sub

Sub Activity_PermissionResult (Permission As String, Result As Boolean)
    If Result Then
       
        If Not(File.Exists(File.DirDefaultExternal, "norfolk_prow.map")) Then
            File.Copy(File.DirAssets, "norfolk_prow.map", File.DirDefaultExternal, "norfolk_prow.map")
        End If
        If Not(File.Exists(File.DirDefaultExternal, "prow_render_theme.xml")) Then
            File.Copy(File.DirAssets, "prow_render_theme.xml", File.DirDefaultExternal, "prow_render_theme.xml")
        End If
       
        Dim MapsForgeTileProviderOptions1 As MapsForgeTileProviderOptions
        MapsForgeTileProviderOptions1.Initialize
        MapsForgeTileProviderOptions1.MapDataStore(File.DirDefaultExternal, "norfolk_prow.map")
        MapsForgeTileProviderOptions1.RenderTheme(File.DirDefaultExternal, "prow_render_theme.xml")
        MapsForgeTileProviderOptions1.Transparent(True)
   
        Dim MapsForgeTileProvider1 As MapsForgeTileProvider
        MapsForgeTileProvider1.Initialize(MapsForgeTileProviderOptions1)
   
        Dim TileOverlayOptions1 As TileOverlayOptions
        TileOverlayOptions1.Initialize
        TileOverlayOptions1.SetTileProvider(MapsForgeTileProvider1)
   
        Dim TileOverlay1 As TileOverlay=GoogleMapsExtras1.AddTileOverlay(GoogleMap1, TileOverlayOptions1)
   
        Dim CameraPosition1 As CameraPosition
        CameraPosition1.Initialize(52.75, 0.44, 10)
        GoogleMap1.MoveCamera(CameraPosition1)
    Else
        Log("PERMISSION_WRITE_EXTERNAL_STORAGE not granted")
    End If
End Sub

Sub MapFragment1_Ready
    GoogleMap1 = MapFragment1.GetMap
    RuntimePermissions1.CheckAndRequest(RuntimePermissions1.PERMISSION_WRITE_EXTERNAL_STORAGE)
End Sub

Sub Activity_Resume
End Sub

'    #AdditionalJar: androidsvg-1.4
'    #AdditionalJar: kxml2-2.3.0
    #AdditionalJar: MapsForgeTileProvider_v5.aar

DEFAULT("/assets/mapsforge/default.xml"),
OSMARENDER("/assets/mapsforge/osmarender.xml");

package org.mapsforge.android.maps;

import android.app.Application;
import android.content.Context;
import android.util.Log;

import com.google.android.gms.maps.model.TileProvider;

import org.mapsforge.core.graphics.TileBitmap;
import org.mapsforge.core.model.Tile;
import org.mapsforge.map.android.graphics.AndroidGraphicFactory;
import org.mapsforge.map.datastore.MapDataStore;
import org.mapsforge.map.layer.cache.InMemoryTileCache;
import org.mapsforge.map.layer.cache.TileCache;
import org.mapsforge.map.layer.hills.HillsRenderConfig;
import org.mapsforge.map.layer.labels.TileBasedLabelStore;
import org.mapsforge.map.layer.renderer.DatabaseRenderer;
import org.mapsforge.map.layer.renderer.RendererJob;
import org.mapsforge.map.model.DisplayModel;
import org.mapsforge.map.model.FixedTileSizeDisplayModel;
import org.mapsforge.map.rendertheme.InternalRenderTheme;
import org.mapsforge.map.rendertheme.XmlRenderTheme;
import org.mapsforge.map.rendertheme.rule.RenderThemeFuture;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class MapsforgeTileProvider implements TileProvider {

   private static final float MAPSFORGE_TILE_PROVIDER_VERSION=1f;

   private static final String TAG= MapsforgeTileProvider.class.getSimpleName();
   private static final int TILE_SIZE=256;

   private static boolean androidGraphicFactoryCreated=false;

   private final ByteArrayOutputStream byteArrayOutputStream;
   private final boolean cacheLabels;
   private final DatabaseRenderer databaseRenderer;
   private final DisplayModel displayModel;
   private final TileCache inMemoryTileCache;
   private final boolean isTransparent;
   private final boolean labelsOnly;
   private final MapDataStore mapDataStore;
   private final com.google.android.gms.maps.model.Tile noTileTile;
   private final RenderThemeFuture renderThemeFuture;
   private final float textScale;

   public MapsforgeTileProvider(Context context, MapsforgeTileProviderOptions mapsForgeTileProviderOptions){

      if(!androidGraphicFactoryCreated){
         AndroidGraphicFactory.createInstance((Application) context.getApplicationContext());
         androidGraphicFactoryCreated=true;
      }

      byteArrayOutputStream=new ByteArrayOutputStream(mapsForgeTileProviderOptions.outputStreamCapacity);
      cacheLabels=mapsForgeTileProviderOptions.cacheLabels;
      displayModel = new FixedTileSizeDisplayModel(TILE_SIZE);
      inMemoryTileCache = new InMemoryTileCache(mapsForgeTileProviderOptions.tileCacheCapacity);
      isTransparent=mapsForgeTileProviderOptions.isTransparent;
      labelsOnly=mapsForgeTileProviderOptions.labelsOnly;
      this.mapDataStore=mapsForgeTileProviderOptions.mapDataStore;
      noTileTile=mapsForgeTileProviderOptions.noTileTile;
      textScale=mapsForgeTileProviderOptions.textScale;

      renderThemeFuture = new RenderThemeFuture(
            AndroidGraphicFactory.INSTANCE,
            mapsForgeTileProviderOptions.xmlRenderTheme,
            displayModel);
      Thread renderThemeFutureThread = new Thread(renderThemeFuture);
      renderThemeFutureThread.start();

      TileBasedLabelStore tileBasedLabelStore = new TileBasedLabelStore(inMemoryTileCache.getCapacityFirstLevel());

      databaseRenderer = new DatabaseRenderer(
            mapDataStore,
            AndroidGraphicFactory.INSTANCE,
            inMemoryTileCache,
            tileBasedLabelStore,
            mapsForgeTileProviderOptions.renderLabels,
            cacheLabels,
            mapsForgeTileProviderOptions.hillsRenderConfig);

   }

   public void close(){
      try {
         byteArrayOutputStream.close();
      } catch (IOException e) {
         Log.e(TAG, null, e);
      }
      renderThemeFuture.cancel(true);    // needed or useful?
      inMemoryTileCache.destroy();
      mapDataStore.close();
   }

   @Override
   public synchronized com.google.android.gms.maps.model.Tile getTile(int x, int y, int zoom) {
      com.google.android.gms.maps.model.Tile googleTile;

      final org.mapsforge.core.model.Tile mapsforgeTile = new Tile(x, y, (byte) zoom, TILE_SIZE);
      if(mapDataStore.supportsTile(mapsforgeTile)){
         final RendererJob rendererJob = new RendererJob(mapsforgeTile, mapDataStore, renderThemeFuture, displayModel, textScale, isTransparent, labelsOnly);

         try {
            final TileBitmap tileBitmap = databaseRenderer.executeJob(rendererJob);
            inMemoryTileCache.put(rendererJob, tileBitmap);
            tileBitmap.compress(byteArrayOutputStream);
            googleTile=new com.google.android.gms.maps.model.Tile(TILE_SIZE, TILE_SIZE, byteArrayOutputStream.toByteArray());
            byteArrayOutputStream.reset();
         } catch (IOException e) {
            Log.e(TAG, null, e);
            googleTile=null;
         }
      } else {
         googleTile=noTileTile;
      }

      return googleTile;
   }

   public static class MapsforgeTileProviderOptions {

      private static final boolean CACHE_LABELS=true;
      private static final HillsRenderConfig HILLS_RENDER_CONFIG=null;
      private static final boolean IS_TRANSPARENT=true;
      private static final boolean LABELS_ONLY=false;
      private static final int OUTPUT_STREAM_CAPACITY=(256*1024);
      private static final boolean RENDER_LABELS=true;
      private static final float TEXT_SCALE=1f;
      private static final int TILE_CACHE_CAPACITY=32;

      protected boolean cacheLabels=CACHE_LABELS;
      protected HillsRenderConfig hillsRenderConfig=HILLS_RENDER_CONFIG;
      protected boolean isTransparent=IS_TRANSPARENT;
      protected boolean labelsOnly=LABELS_ONLY;
      protected MapDataStore mapDataStore=null;
      protected com.google.android.gms.maps.model.Tile noTileTile=com.google.android.gms.maps.model.TileProvider.NO_TILE;
      protected int outputStreamCapacity=OUTPUT_STREAM_CAPACITY;
      protected boolean renderLabels=RENDER_LABELS;
      protected float textScale=TEXT_SCALE;
      protected int tileCacheCapacity=TILE_CACHE_CAPACITY;
      protected XmlRenderTheme xmlRenderTheme=InternalRenderTheme.OSMARENDER;

      public void setCacheLabels(boolean cacheLabels){
         this.cacheLabels=cacheLabels;
      }

      public void setLabelsOnly(boolean labelsOnly) {
         this.labelsOnly = labelsOnly;
      }

      public void setMapDataStore(MapDataStore mapDataStore) {
         this.mapDataStore = mapDataStore;
      }

      public void setNoTileTile(com.google.android.gms.maps.model.Tile noTileTile){
         this.noTileTile=noTileTile;
      }

      public void setOutputStreamCapacity(int outputStreamCapacity) {
         this.outputStreamCapacity = outputStreamCapacity;
      }

      public void setRenderLabels(boolean renderLabels) {
         this.renderLabels = renderLabels;
      }

      public void setRenderTheme(XmlRenderTheme xmlRenderTheme){
         this.xmlRenderTheme=xmlRenderTheme;
      }

      public void setTextScale(float textScale) {
         this.textScale = textScale;
      }

      public void setTileCacheCapacity(int tileCacheCapacity) {
         this.tileCacheCapacity = tileCacheCapacity;
      }

      public void setTransparent(boolean transparent) {
         isTransparent = transparent;
      }
   }
}

private AndroidGraphicFactory(Application app) {
    this.application = app;
    if (app != null) {
        // the scaledDensity is an approximate scale factor for the device
        DisplayModel.setDeviceScaleFactor(app.getResources().getDisplayMetrics().scaledDensity);
    }
}