Fixes #2826, Found caches shown on live map

Implemented detection and filtering for vanishing caches
Added testcases for new functionality

9 files changed, 175 insertions, 12 deletions

diff --git a/main/src/cgeo/geocaching/SearchResult.java b/main/src/cgeo/geocaching/SearchResult.java
index 94ce28d..5053a85 100644
--- a/main/src/cgeo/geocaching/SearchResult.java
+++ b/main/src/cgeo/geocaching/SearchResult.java
@@ -24,6 +24,7 @@ import java.util.Set;
 public class SearchResult implements Parcelable {
 
     final private Set<String> geocodes;
+    final private Set<String> filteredGeocodes;
     private StatusCode error = null;
     private String url = "";
     public String[] viewstates = null;
@@ -55,6 +56,7 @@ public class SearchResult implements Parcelable {
      */
     public SearchResult(final SearchResult searchResult) {
         geocodes = new HashSet<String>(searchResult.geocodes);
+        filteredGeocodes = new HashSet<String>(searchResult.filteredGeocodes);
         error = searchResult.error;
         url = searchResult.url;
         viewstates = searchResult.viewstates;
@@ -70,6 +72,7 @@ public class SearchResult implements Parcelable {
     public SearchResult(final Collection<String> geocodes, final int total) {
         this.geocodes = new HashSet<String>(geocodes.size());
         this.geocodes.addAll(geocodes);
+        this.filteredGeocodes = new HashSet<String>();
         this.setTotal(total);
     }
 
@@ -86,6 +89,9 @@ public class SearchResult implements Parcelable {
         final ArrayList<String> list = new ArrayList<String>();
         in.readStringList(list);
         geocodes = new HashSet<String>(list);
+        final ArrayList<String> filteredList = new ArrayList<String>();
+        in.readStringList(filteredList);
+        filteredGeocodes = new HashSet<String>(filteredList);
         error = (StatusCode) in.readSerializable();
         url = in.readString();
         final int length = in.readInt();
@@ -121,6 +127,7 @@ public class SearchResult implements Parcelable {
     @Override
     public void writeToParcel(final Parcel out, final int flags) {
         out.writeStringArray(geocodes.toArray(new String[geocodes.size()]));
+        out.writeStringArray(filteredGeocodes.toArray(new String[filteredGeocodes.size()]));
         out.writeSerializable(error);
         out.writeString(url);
         if (viewstates == null) {
@@ -252,4 +259,19 @@ public class SearchResult implements Parcelable {
         return false;
     }
 
+    public void addFilteredGeocodes(Set<String> cachedMissingFromSearch) {
+        filteredGeocodes.addAll(cachedMissingFromSearch);
+    }
+
+    public Set<String> getFilteredGeocodes() {
+        return Collections.unmodifiableSet(filteredGeocodes);
+    }
+
+    public void addSearchResult(SearchResult other) {
+        if (other != null) {
+            addGeocodes(other.geocodes);
+            addFilteredGeocodes(other.filteredGeocodes);
+        }
+    }
+
 }
diff --git a/main/src/cgeo/geocaching/cgData.java b/main/src/cgeo/geocaching/cgData.java
index 6f535dc..adb3612 100644
--- a/main/src/cgeo/geocaching/cgData.java
+++ b/main/src/cgeo/geocaching/cgData.java
@@ -1,5 +1,7 @@
 package cgeo.geocaching;
 
+import cgeo.geocaching.connector.IConnector;
+import cgeo.geocaching.connector.gc.Tile;
 import cgeo.geocaching.enumerations.CacheSize;
 import cgeo.geocaching.enumerations.CacheType;
 import cgeo.geocaching.enumerations.LoadFlags;
@@ -2975,4 +2977,35 @@ public class cgData {
         return false;
     }
 
+    public static Set<String> getCachedMissingFromSearch(SearchResult searchResult, Set<Tile> tiles, IConnector connector) {
+
+        // get cached cgeocaches
+        final Set<String> cachedGeocodes = new HashSet<String>();
+        for (Tile tile : tiles) {
+            cachedGeocodes.addAll(cacheCache.getInViewport(tile.getViewport(), CacheType.ALL));
+        }
+        // remove found in search result
+        cachedGeocodes.removeAll(searchResult.getGeocodes());
+
+        // check remaining against viewports
+        Set<String> missingFromSearch = new HashSet<String>();
+        for (String geocode : cachedGeocodes) {
+            if (connector.canHandle(geocode)) {
+                Geocache geocache = cacheCache.getCacheFromCache(geocode);
+                boolean bFound = false;
+                for (Tile tile : tiles) {
+                    if (tile.containsPoint(geocache)) {
+                        bFound = true;
+                        break;
+                    }
+                }
+                if (bFound) {
+                    missingFromSearch.add(geocode);
+                }
+            }
+        }
+
+        return missingFromSearch;
+    }
+
 }
diff --git a/main/src/cgeo/geocaching/connector/ConnectorFactory.java b/main/src/cgeo/geocaching/connector/ConnectorFactory.java
index c5a083c..eb09978 100644
--- a/main/src/cgeo/geocaching/connector/ConnectorFactory.java
+++ b/main/src/cgeo/geocaching/connector/ConnectorFactory.java
@@ -147,10 +147,7 @@ public final class ConnectorFactory {
         final SearchResult result = new SearchResult();
         for (final ISearchByViewPort vpconn : searchByViewPortConns) {
             if (vpconn.isActivated()) {
-                final SearchResult temp = vpconn.searchByViewport(viewport, tokens);
-                if (temp != null) {
-                    result.addGeocodes(temp.getGeocodes());
-                }
+                result.addSearchResult(vpconn.searchByViewport(viewport, tokens));
             }
         }
         return result;
diff --git a/main/src/cgeo/geocaching/connector/gc/GCMap.java b/main/src/cgeo/geocaching/connector/gc/GCMap.java
index 643caf5..13b663b 100644
--- a/main/src/cgeo/geocaching/connector/gc/GCMap.java
+++ b/main/src/cgeo/geocaching/connector/gc/GCMap.java
@@ -337,7 +337,7 @@ public class GCMap {
                             Log.e("GCMap.searchByViewport: No cache parsed for viewport " + viewport);
                         }
                         else {
-                            searchResult.addGeocodes(search.getGeocodes());
+                            searchResult.addSearchResult(search);
                         }
                         Tile.Cache.add(tile);
                     }
@@ -349,6 +349,11 @@ public class GCMap {
 
                 }
             }
+
+            // Check for vanished found caches
+            if (tiles.iterator().next().getZoomlevel() >= Tile.ZOOMLEVEL_MIN_PERSONALIZED) {
+                searchResult.addFilteredGeocodes(cgData.getCachedMissingFromSearch(searchResult, tiles, GCConnector.getInstance()));
+            }
         }
 
         if (strategy.flags.contains(StrategyFlag.SEARCH_NEARBY)) {
diff --git a/main/src/cgeo/geocaching/connector/gc/Tile.java b/main/src/cgeo/geocaching/connector/gc/Tile.java
index dd7f352..ec90036 100644
--- a/main/src/cgeo/geocaching/connector/gc/Tile.java
+++ b/main/src/cgeo/geocaching/connector/gc/Tile.java
@@ -37,6 +37,7 @@ public class Tile {
     public static final int TILE_SIZE = 256;
     public static final int ZOOMLEVEL_MAX = 18;
     public static final int ZOOMLEVEL_MIN = 0;
+    public static final int ZOOMLEVEL_MIN_PERSONALIZED = 12;
 
     static final int[] NUMBER_OF_TILES = new int[ZOOMLEVEL_MAX - ZOOMLEVEL_MIN + 1];
     static final int[] NUMBER_OF_PIXELS = new int[ZOOMLEVEL_MAX - ZOOMLEVEL_MIN + 1];
@@ -252,6 +253,10 @@ public class Tile {
         return viewPort.contains(point);
     }
 
+    public Viewport getViewport() {
+        return viewPort;
+    }
+
     /**
      * Calculate needed tiles for the given viewport to cover it with
      * max 2x2 tiles
diff --git a/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java b/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java
index 09ea459..928aaea 100644
--- a/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java
+++ b/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java
@@ -27,10 +27,7 @@ public class CoordsGeocacheListLoader extends AbstractSearchLoader {
 
         for (ISearchByCenter centerConn : ConnectorFactory.getSearchByCenterConnectors()) {
             if (centerConn.isActivated()) {
-                SearchResult temp = centerConn.searchByCenter(coords);
-                if (temp != null) {
-                    search.addGeocodes(temp.getGeocodes());
-                }
+                search.addSearchResult(centerConn.searchByCenter(coords));
             }
         }
 
diff --git a/main/src/cgeo/geocaching/maps/CGeoMap.java b/main/src/cgeo/geocaching/maps/CGeoMap.java
index c876192..a2b70c7 100644
--- a/main/src/cgeo/geocaching/maps/CGeoMap.java
+++ b/main/src/cgeo/geocaching/maps/CGeoMap.java
@@ -17,6 +17,7 @@ import cgeo.geocaching.connector.gc.Login;
 import cgeo.geocaching.enumerations.CacheType;
 import cgeo.geocaching.enumerations.LiveMapStrategy.Strategy;
 import cgeo.geocaching.enumerations.LoadFlags;
+import cgeo.geocaching.enumerations.LoadFlags.RemoveFlag;
 import cgeo.geocaching.enumerations.StatusCode;
 import cgeo.geocaching.enumerations.WaypointType;
 import cgeo.geocaching.geopoint.Geopoint;
@@ -70,6 +71,7 @@ import android.widget.ViewSwitcher.ViewFactory;
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -1082,8 +1084,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto
                 }
                 // live mode search result
                 if (isLiveEnabled) {
-                    SearchResult liveResult = new SearchResult(cgData.loadCachedInViewport(viewport, Settings.getCacheType()));
-                    searchResult.addGeocodes(liveResult.getGeocodes());
+                    searchResult.addSearchResult(cgData.loadCachedInViewport(viewport, Settings.getCacheType()));
                 }
 
                 downloaded = true;
@@ -1179,7 +1180,12 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto
                     Set<Geocache> result = searchResult.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
                     CGeoMap.filter(result);
                     // update the caches
-                    // new collection type needs to remove first
+                    // first remove filtered out
+                    final Set<String> filteredCodes = searchResult.getFilteredGeocodes();
+                    Log.d("Filtering out " + filteredCodes.size() + " caches: " + filteredCodes.toString());
+                    caches.removeAll(cgData.loadCaches(filteredCodes, LoadFlags.LOAD_CACHE_ONLY));
+                    cgData.removeCaches(filteredCodes, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+                    // new collection type needs to remove first to refresh
                     caches.removeAll(result);
                     caches.addAll(result);
                     lastSearchResult = searchResult;
diff --git a/tests/src/cgeo/geocaching/SearchResultTest.java b/tests/src/cgeo/geocaching/SearchResultTest.java
index 8fcd188..9bce5a5 100644
--- a/tests/src/cgeo/geocaching/SearchResultTest.java
+++ b/tests/src/cgeo/geocaching/SearchResultTest.java
@@ -1,8 +1,10 @@
 package cgeo.geocaching;
 
+import android.os.Parcel;
 import android.test.AndroidTestCase;
 
 import java.util.HashSet;
+import java.util.Set;
 
 public class SearchResultTest extends AndroidTestCase {
     public static void testCreateFromGeocodes() {
@@ -14,4 +16,60 @@ public class SearchResultTest extends AndroidTestCase {
         assertEquals(2, searchResult.getTotal());
         assertTrue(searchResult.getGeocodes().contains("GC12345"));
     }
+
+    public static void testParcel() {
+        final Set<String> geocodes = new HashSet<String>();
+        geocodes.add("GC12345");
+        geocodes.add("GC23456");
+        geocodes.add("GC34567");
+        final SearchResult search = new SearchResult(geocodes);
+        geocodes.clear();
+        geocodes.add("GC45678");
+        geocodes.add("GC56789");
+        search.addFilteredGeocodes(geocodes);
+
+        Parcel parcel = Parcel.obtain();
+        search.writeToParcel(parcel, 0);
+        // reset to ready for reading
+        parcel.setDataPosition(0);
+
+        final SearchResult receive = new SearchResult(parcel);
+
+        parcel.recycle();
+
+        assertEquals(3, receive.getCount());
+        assertEquals(2, receive.getFilteredGeocodes().size());
+
+        assertTrue(receive.getGeocodes().contains("GC12345"));
+        assertFalse(receive.getGeocodes().contains("GC45678"));
+
+        assertFalse(receive.getFilteredGeocodes().contains("GC12345"));
+        assertTrue(receive.getFilteredGeocodes().contains("GC45678"));
+    }
+
+    public static void testAddSearchResult() {
+        final Set<String> geocodes = new HashSet<String>();
+        geocodes.add("GC12345");
+        geocodes.add("GC23456");
+        geocodes.add("GC34567");
+        final SearchResult search = new SearchResult(geocodes);
+        geocodes.clear();
+        geocodes.add("GC45678");
+        geocodes.add("GC56789");
+        search.addFilteredGeocodes(geocodes);
+
+        final SearchResult newSearch = new SearchResult();
+        newSearch.addGeocode("GC01234");
+        newSearch.addSearchResult(search);
+
+        assertEquals(4, newSearch.getCount());
+        assertEquals(2, newSearch.getFilteredGeocodes().size());
+
+        assertTrue(newSearch.getGeocodes().contains("GC12345"));
+        assertTrue(newSearch.getGeocodes().contains("GC01234"));
+        assertFalse(newSearch.getGeocodes().contains("GC45678"));
+
+        assertFalse(newSearch.getFilteredGeocodes().contains("GC12345"));
+        assertTrue(newSearch.getFilteredGeocodes().contains("GC45678"));
+    }
 }
diff --git a/tests/src/cgeo/geocaching/cgDataTest.java b/tests/src/cgeo/geocaching/cgDataTest.java
index cc1148a..7ea4b21 100644
--- a/tests/src/cgeo/geocaching/cgDataTest.java
+++ b/tests/src/cgeo/geocaching/cgDataTest.java
@@ -1,6 +1,8 @@
 package cgeo.geocaching;
 
 import cgeo.CGeoTestCase;
+import cgeo.geocaching.connector.gc.GCConnector;
+import cgeo.geocaching.connector.gc.Tile;
 import cgeo.geocaching.enumerations.CacheType;
 import cgeo.geocaching.enumerations.LoadFlags;
 import cgeo.geocaching.enumerations.LoadFlags.SaveFlag;
@@ -149,4 +151,42 @@ public class cgDataTest extends CGeoTestCase {
         // check that two different routines behave the same
         assertEquals(cgData.getAllHistoryCachesCount(), sumCaches);
     }
+
+    public static void testCachedMissing() {
+
+        // Tile to test
+        final Tile tile = new Tile(new Geopoint("N49 44.0 E8 37.0"), 14);
+        final Set<Tile> tiles = new HashSet<Tile>();
+        tiles.add(tile);
+
+        // set up geocaches to fill into cacheCache
+        final Geocache main = new Geocache();
+        main.setGeocode("GC12345");
+        main.setCoords(new Geopoint("N49 44.0 E8 37.0"));
+        final Geocache inTile = new Geocache();
+        inTile.setGeocode("GC12346");
+        inTile.setCoords(new Geopoint("N49 44.001 E8 37.001"));
+        final Geocache outTile = new Geocache();
+        outTile.setGeocode("GC12347");
+        outTile.setCoords(new Geopoint(tile.getViewport().getLatitudeMin() - 0.1, tile.getViewport().getLongitudeMin() - 0.1));
+        final Geocache otherConnector = new Geocache();
+        otherConnector.setGeocode("OC0001");
+        otherConnector.setCoords(new Geopoint("N49 44.0 E8 37.0"));
+
+        // put in cache
+        cgData.saveCache(main, EnumSet.of(SaveFlag.SAVE_CACHE));
+        cgData.saveCache(inTile, EnumSet.of(SaveFlag.SAVE_CACHE));
+        cgData.saveCache(outTile, EnumSet.of(SaveFlag.SAVE_CACHE));
+        cgData.saveCache(otherConnector, EnumSet.of(SaveFlag.SAVE_CACHE));
+
+        final SearchResult search = new SearchResult(main);
+
+        Set<String> filteredGeoCodes = cgData.getCachedMissingFromSearch(search, tiles, GCConnector.getInstance());
+
+        assertTrue(filteredGeoCodes.contains(inTile.getGeocode()));
+        assertFalse(filteredGeoCodes.contains(otherConnector.getGeocode()));
+        assertFalse(filteredGeoCodes.contains(outTile.getGeocode()));
+        assertFalse(filteredGeoCodes.contains(main.getGeocode()));
+
+    }
 }