feature/#1004 - offline first

OpenStreetMapViewer/src/main/java/org/osmdroid/samplefragments/SampleFactory.java

@@ -91,6 +91,7 @@
 import org.osmdroid.samplefragments.tilesources.SampleCustomTileSource;
 import org.osmdroid.samplefragments.tilesources.SampleHereWeGo;
 import org.osmdroid.samplefragments.tilesources.SampleInvertedTiles_NightMode;
+import org.osmdroid.samplefragments.tilesources.SampleLieFi;
 import org.osmdroid.samplefragments.tilesources.SampleMapBox;
 import org.osmdroid.samplefragments.tilesources.SampleMapQuest;
 import org.osmdroid.samplefragments.tilesources.SampleOpenSeaMap;
@@ -293,6 +294,7 @@ private SampleFactory() {
         mSamples.add(SampleZoomRounding.class);
         mSamples.add(LayerManager.class);
         mSamples.add(BookmarkSample.class);
+        mSamples.add(SampleLieFi.class);
     }
 
     public void addSample(Class<? extends BaseSampleFragment> clz) {

OpenStreetMapViewer/src/main/java/org/osmdroid/samplefragments/tilesources/SampleLieFi.java

@@ -0,0 +1,173 @@
+package org.osmdroid.samplefragments.tilesources;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.osmdroid.samplefragments.BaseSampleFragment;
+import org.osmdroid.tileprovider.IMapTileProviderCallback;
+import org.osmdroid.tileprovider.IRegisterReceiver;
+import org.osmdroid.tileprovider.MapTileProviderArray;
+import org.osmdroid.tileprovider.modules.IFilesystemCache;
+import org.osmdroid.tileprovider.modules.INetworkAvailablityCheck;
+import org.osmdroid.tileprovider.modules.MapTileApproximater;
+import org.osmdroid.tileprovider.modules.MapTileAssetsProvider;
+import org.osmdroid.tileprovider.modules.MapTileDownloader;
+import org.osmdroid.tileprovider.modules.MapTileFileArchiveProvider;
+import org.osmdroid.tileprovider.modules.MapTileFileStorageProviderBase;
+import org.osmdroid.tileprovider.modules.MapTileFilesystemProvider;
+import org.osmdroid.tileprovider.modules.MapTileSqlCacheProvider;
+import org.osmdroid.tileprovider.modules.NetworkAvailabliltyCheck;
+import org.osmdroid.tileprovider.modules.SqlTileWriter;
+import org.osmdroid.tileprovider.modules.TileWriter;
+import org.osmdroid.tileprovider.tilesource.ITileSource;
+import org.osmdroid.tileprovider.tilesource.TileSourceFactory;
+import org.osmdroid.tileprovider.util.SimpleRegisterReceiver;
+import org.osmdroid.util.GeoPoint;
+import org.osmdroid.views.MapView;
+
+/**
+ * Lie Fi demo: we emulate a slow online source in order to show the offline first behavior
+ * @since 6.0.2
+ * @author Fabrice Fontaine
+ */
+public class SampleLieFi extends BaseSampleFragment {
+
+    private final GeoPoint mInitialCenter = new GeoPoint(41.8905495, 12.4924348); // Rome, Italy
+    private final double mInitialZoomLevel = 5;
+    private final int mLieFieLagInMillis = 1000;
+
+    @Override
+    public String getSampleTitle() {
+          return "Lie Fi - slow online source";
+     }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        final MapTileProviderArray provider = new MapTileProviderLieFi(inflater.getContext());
+        mMapView = new MapView(inflater.getContext(), provider);
+        return mMapView;
+    }
+
+    @Override
+    protected void addOverlays() {
+        super.addOverlays();
+
+        mMapView.post(new Runnable() { // "post" because we need View.getWidth() to be set
+            @Override
+            public void run() {
+                mMapView.getController().setZoom(mInitialZoomLevel);
+                mMapView.setExpectedCenter(mInitialCenter);
+            }
+        });
+    }
+
+    private class MapTileProviderLieFi extends MapTileProviderArray implements IMapTileProviderCallback {
+
+        private IFilesystemCache tileWriter;
+        private final INetworkAvailablityCheck mNetworkAvailabilityCheck;
+
+        private MapTileProviderLieFi(final Context pContext) {
+            this(new SimpleRegisterReceiver(pContext), new NetworkAvailabliltyCheck(pContext),
+                    TileSourceFactory.DEFAULT_TILE_SOURCE, pContext,null);
+        }
+
+        private MapTileProviderLieFi(final IRegisterReceiver pRegisterReceiver,
+                                    final INetworkAvailablityCheck aNetworkAvailablityCheck, final ITileSource pTileSource,
+                                    final Context pContext, final IFilesystemCache cacheWriter) {
+            super(pTileSource, pRegisterReceiver);
+            mNetworkAvailabilityCheck = aNetworkAvailablityCheck;
+
+            if (cacheWriter != null) {
+                tileWriter = cacheWriter;
+            } else {
+                if (Build.VERSION.SDK_INT < 10) {
+                    tileWriter = new TileWriter();
+                } else {
+                    tileWriter = new SqlTileWriter();
+                }
+            }
+            final MapTileAssetsProvider assetsProvider = new MapTileAssetsProvider(
+                    pRegisterReceiver, pContext.getAssets(), pTileSource);
+            mTileProviderList.add(assetsProvider);
+
+            final MapTileFileStorageProviderBase cacheProvider;
+            if (Build.VERSION.SDK_INT < 10) {
+                cacheProvider = new MapTileFilesystemProvider(pRegisterReceiver, pTileSource);
+            } else {
+                cacheProvider = new MapTileSqlCacheProvider(pRegisterReceiver, pTileSource);
+            }
+            mTileProviderList.add(cacheProvider);
+
+            final MapTileFileArchiveProvider archiveProvider = new MapTileFileArchiveProvider(
+                    pRegisterReceiver, pTileSource);
+            mTileProviderList.add(archiveProvider);
+
+            final MapTileApproximater approximationProvider = new MapTileApproximater();
+            mTileProviderList.add(approximationProvider);
+            approximationProvider.addProvider(assetsProvider);
+            approximationProvider.addProvider(cacheProvider);
+            approximationProvider.addProvider(archiveProvider);
+
+            final MapTileDownloader downloaderProvider = new MapTileDownloaderLieFi(pTileSource, tileWriter,
+                    aNetworkAvailablityCheck);
+            mTileProviderList.add(downloaderProvider);
+
+            getTileCache().getProtectedTileContainers().add(this);
+        }
+
+        @Override
+        public IFilesystemCache getTileWriter() {
+            return tileWriter;
+        }
+
+        @Override
+        public void detach(){
+            //https://github.com/osmdroid/osmdroid/issues/213
+            //close the writer
+            if (tileWriter!=null)
+                tileWriter.onDetach();
+            tileWriter=null;
+            super.detach();
+        }
+
+        /**
+         * @since 6.0
+         */
+        @Override
+        protected boolean isDowngradedMode() {
+            return (mNetworkAvailabilityCheck != null && !mNetworkAvailabilityCheck.getNetworkAvailable())
+                    || !useDataConnection();
+        }
+    }
+
+    private class MapTileDownloaderLieFi extends MapTileDownloader {
+
+        private final MapTileDownloader.TileLoader mTileLoader = new TileLoader();
+
+        MapTileDownloaderLieFi(ITileSource pTileSource, IFilesystemCache pFilesystemCache, INetworkAvailablityCheck pNetworkAvailablityCheck) {
+            super(pTileSource, pFilesystemCache, pNetworkAvailablityCheck);
+        }
+
+        @Override
+        public MapTileDownloader.TileLoader getTileLoader() {
+            return mTileLoader;
+        }
+
+        private class TileLoader extends MapTileDownloader.TileLoader {
+            @Override
+            protected Drawable downloadTile(long pMapTileIndex, int redirectCount, String targetUrl) throws CantContinueException {
+                try {
+                    Thread.sleep(mLieFieLagInMillis);
+                } catch(InterruptedException e) {
+                    //
+                }
+                return super.downloadTile(pMapTileIndex, redirectCount, targetUrl);
+            }
+        }
+    }
+}

osmdroid-android/src/main/java/org/osmdroid/tileprovider/MapTileCache.java

@@ -3,6 +3,7 @@
 
 import org.osmdroid.api.IMapView;
 import org.osmdroid.config.Configuration;
+import org.osmdroid.util.MapTileContainer;
 import org.osmdroid.util.MapTileList;
 import org.osmdroid.util.MapTileListComputer;
 
@@ -56,6 +57,11 @@ public interface TileRemovedListener {
 
 	private final MapTilePreCache mPreCache;
 
+	/**
+	 * @since 6.0.2
+	 */
+	private final List<MapTileContainer> mProtectors = new ArrayList<>();
+
 	// ===========================================================
 	// Constructors
 	// ===========================================================
@@ -80,6 +86,13 @@ public List<MapTileListComputer> getProtectedTileComputers() {
 		return mComputers;
 	}
 
+	/**
+	 * @since 6.0.2
+	 */
+	public List<MapTileContainer> getProtectedTileContainers() {
+		return mProtectors;
+	}
+
 	// ===========================================================
 	// Getter & Setter
 	// ===========================================================
@@ -122,10 +135,7 @@ public void garbageCollection() {
 		populateSyncCachedTiles(mGC);
 		for (int i = 0; i < mGC.getSize() ; i ++) {
 			final long index = mGC.get(i);
-			if (mMapTileList.contains(index)) {
-				continue;
-			}
-			if (mAdditionalMapTileList.contains(index)) {
+			if (shouldKeepTile(index)) {
 				continue;
 			}
 			remove(index);
@@ -135,6 +145,24 @@ public void garbageCollection() {
 		}
 	}
 
+	/**
+	 * @since 6.0.2
+	 */
+	private boolean shouldKeepTile(final long pMapTileIndex) {
+		if (mMapTileList.contains(pMapTileIndex)) {
+			return true;
+		}
+		if (mAdditionalMapTileList.contains(pMapTileIndex)) {
+			return true;
+		}
+		for(final MapTileContainer container : mProtectors) {
+			if (container.contains(pMapTileIndex)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * @since 6.0.0
 	 */