Initial commit.

Author: evelyne24

.gitignore

@@ -1,3 +1,5 @@
+.DS_Store
+
 # built application files
 *.apk
 *.ap_
@@ -11,10 +13,13 @@
 # generated files
 bin/
 gen/
+build/
 
 # Local configuration file (sdk path, etc)
 local.properties
 
-# Eclipse project files
+# IDE project files
 .classpath
 .project
+*.iml
+.idea

.gradle/1.6/taskArtifacts/cache.properties

@@ -0,0 +1 @@
+#Fri Aug 30 19:01:30 BST 2013

.gradle/1.6/taskArtifacts/cache.properties.lock

@@ -0,0 +1 @@
+

.gradle/1.6/taskArtifacts/fileHashes.bin

@@ -0,0 +1 @@
+#Fri Aug 30 18:47:07 BST 2013

.gradle/1.6/taskArtifacts/fileSnapshots.bin

@@ -0,0 +1 @@
+

.gradle/1.6/taskArtifacts/outputFileStates.bin

@@ -0,0 +1,22 @@
+apply plugin: 'android-library'
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+dependencies {
+    compile 'com.google.android.gms:play-services:3.1.36'
+    compile 'com.android.support:support-v4:18.0.+'
+    compile 'com.android.support:appcompat-v7:18.0.+'
+}
+
+android {
+    compileSdkVersion 18
+    buildToolsVersion "18.0.1"
+
+    defaultConfig {
+        minSdkVersion 8
+        targetSdkVersion 18
+    }
+}

.gradle/1.6/taskArtifacts/taskArtifacts.bin

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.codeandmagic.cartocache"
+    android:versionCode="1"
+    android:versionName="1.0">
+
+    <uses-sd
+        android:minSdkVersion="8"
+        android:targetSdkVersion="18" />
+
+    <application></application>
+
+</manifest>

.gradle/1.7/taskArtifacts/cache.properties

@@ -0,0 +1,145 @@
+package com.codeandmagic.cartocache;
+
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.PolygonOptions;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import static com.codeandmagic.cartocache.QTile.EMPTY_ARRAY;
+import static com.codeandmagic.cartocache.QTile.getTile;
+import static com.codeandmagic.cartocache.Utils.diff;
+
+/**
+ * Created by evelyne24.
+ */
+public class CartoCache<P extends Place> implements GoogleMap.OnCameraChangeListener, DataFetcher.Callback<P> {
+
+    private static final L log = L.getLog(CartoCache.class);
+
+    private final GoogleMap map;
+    private final CartoCacheConfig<P> config;
+
+    private Map<QTile, Polygon> drawnTiles = new HashMap<QTile, Polygon>();
+    private Map<QTile, List<Marker>> markers = new HashMap<QTile, List<Marker>>();
+    private QTile[] visibleTiles = EMPTY_ARRAY;
+
+    public CartoCache(CartoCacheConfig<P> config, GoogleMap map) {
+        this.config = config;
+        this.map = map;
+        this.map.setOnCameraChangeListener(this);
+    }
+
+    @Override
+    public void onCameraChange(CameraPosition cameraPosition) {
+        final LatLng latLng = cameraPosition.target;
+        final ZoomLevel zoom = getDataFetchZoom(cameraPosition.zoom);
+        final QTile centerTile = getTile(latLng, zoom);
+        centerTile.initNeighbourTiles();
+
+        QTile[] newTiles = new QTile[4];
+        newTiles[0] = centerTile;
+
+        QTile[] neighbours = centerTile.getClosestNeighbourTiles(latLng);
+        System.arraycopy(neighbours, 0, newTiles, 1, neighbours.length);
+
+        QTile[] removedTiles = diff(visibleTiles, newTiles, EMPTY_ARRAY);
+        QTile[] addedTiles = diff(newTiles, visibleTiles, EMPTY_ARRAY);
+
+        // Delete markers for all remove drawnTiles
+        for (QTile tile : removedTiles) {
+            removePlacesForTile(tile);
+        }
+
+        // Delete all tile debug squares
+        for (Map.Entry<QTile, Polygon> entry : drawnTiles.entrySet()) {
+            entry.getValue().remove();
+        }
+
+        if (config.debug) {
+            drawnTiles.clear();
+
+            // Add all new tile debug squares
+            for (QTile tile : newTiles) {
+                drawnTiles.put(tile, drawTile(tile, tile.equals(centerTile) ? config.currentTileConfig : config.tileConfig));
+            }
+        }
+
+        // Add markers for new added drawnTiles:
+        // First verify if the drawnTiles are in cache.
+        // If not, request places for the new drawnTiles.
+        for (QTile qTile : addedTiles) {
+            Collection<P> places = config.placesCache.get(qTile);
+            if (places != null) {
+                if(config.debug) {
+                    log.i("Cache HIT for QTile " + qTile.quadKey);
+                }
+                addPlacesForTile(qTile, places);
+            } else {
+                if(config.debug) {
+                    log.w("Cache MISS for QTile " + qTile.quadKey);
+                }
+                config.dataFetcher.requestPlaces(qTile, this);
+            }
+        }
+
+        visibleTiles = newTiles;
+    }
+
+    private ZoomLevel getDataFetchZoom(float cameraZoom) {
+        final int seeAllScreenZoom = (int) (cameraZoom - 1);
+        if (seeAllScreenZoom < 1) {
+            return ZoomLevel.Z1;
+        }
+        if (seeAllScreenZoom > config.maxDataFetchZoom.zoom) {
+            return config.maxDataFetchZoom;
+        }
+        return ZoomLevel.get(seeAllScreenZoom);
+    }
+
+    private void removePlacesForTile(QTile qTile) {
+        final List<Marker> list = markers.get(qTile);
+        if (list != null) {
+            for (Marker marker : list) {
+                marker.remove();
+            }
+        }
+        markers.remove(qTile);
+    }
+
+    private void addPlacesForTile(QTile qTile, Collection<P> places) {
+        final List<Marker> list = new ArrayList<Marker>();
+        for (P place : places) {
+            list.add(map.addMarker(config.markerConfig.getMarker(place)));
+        }
+        markers.put(qTile, list);
+    }
+
+    private Polygon drawTile(QTile tile, QTileDrawConfig config) {
+        return map.addPolygon(new PolygonOptions()
+                .add(tile.topLeft, tile.topRight, tile.bottomRight, tile.bottomLeft)
+                .fillColor(config.fillColor)
+                .strokeColor(config.strokeColor)
+                .strokeWidth(config.strokeWidth));
+    }
+
+
+    @Override
+    public void onSuccess(QTile qTile, Collection<P> places) {
+        config.placesCache.add(qTile, places);
+        addPlacesForTile(qTile, config.placesCache.get(qTile));
+    }
+
+    @Override
+    public void onError(QTile qTile, Throwable e) {
+
+    }
+}

.gradle/1.7/taskArtifacts/cache.properties.lock

@@ -0,0 +1,102 @@
+package com.codeandmagic.cartocache;
+
+import android.graphics.Color;
+
+/**
+ * Created by evelyne24.
+ */
+public class CartoCacheConfig<P extends Place> {
+
+    public static class Builder<P extends Place> {
+        private boolean debug = true;
+        public QTileDrawConfig currentTileConfig = new QTileDrawConfig(Color.parseColor("#77ff8282"), Color.RED, 2);
+        public QTileDrawConfig tileConfig = new QTileDrawConfig(Color.parseColor("#77b0b1ff"), Color.BLUE, 1);
+
+        private ZoomLevel maxDataFetchZoom = ZoomLevel.Z17;
+        private ZoomLevel minDataFetchZoom = ZoomLevel.Z11;
+        private ZoomLevel clusteringZoom = ZoomLevel.Z13;
+        private MarkerConfig<P> markerConfig = new DefaultMarkerConfig<P>();
+        private PlacesCache<P> placesCache = new DefaultPlaceCache<P>(false);
+        private DataFetcher<P> dataFetcher;
+
+
+        public Builder<P> setDebug(boolean debug) {
+            this.debug = debug;
+            return this;
+        }
+
+        public Builder<P> setCurrentTileConfig(QTileDrawConfig currentTileConfig) {
+            this.currentTileConfig = currentTileConfig;
+            return this;
+        }
+
+        public Builder<P> setTileConfig(QTileDrawConfig tileConfig) {
+            this.tileConfig = tileConfig;
+            return this;
+        }
+
+        public Builder<P> setMinDataFetchZoom(ZoomLevel minDataFetchZoom) {
+            this.minDataFetchZoom = minDataFetchZoom;
+            return this;
+        }
+
+        public Builder<P> setMaxDataFetchZoom(ZoomLevel maxDataFetchZoom) {
+            this.maxDataFetchZoom = maxDataFetchZoom;
+            return this;
+        }
+
+        public Builder<P> setClusteringZoom(ZoomLevel clusteringZoom) {
+            this.clusteringZoom = clusteringZoom;
+            return this;
+        }
+
+        public Builder<P> setMarkerConfig(MarkerConfig<P> markerConfig) {
+            this.markerConfig = markerConfig;
+            return this;
+        }
+
+        public Builder<P> setPlacesCache(PlacesCache<P> placesCache) {
+            this.placesCache = placesCache;
+            return this;
+        }
+
+        public Builder<P> setDataFetcher(DataFetcher<P> dataFetcher) {
+            this.dataFetcher = dataFetcher;
+            return this;
+        }
+
+
+        public CartoCacheConfig<P> build() {
+            if(dataFetcher == null) {
+                throw new IllegalArgumentException("Missing required DataFetcher configuration.");
+            }
+            return new CartoCacheConfig<P>(this);
+        }
+    }
+
+    public final boolean debug;
+    public final QTileDrawConfig currentTileConfig;
+    public final QTileDrawConfig tileConfig;
+
+    public final ZoomLevel maxDataFetchZoom;
+    public final ZoomLevel minDataFetchZoom;
+    public final ZoomLevel clusteringZoom;
+    public final MarkerConfig<P> markerConfig;
+    public final PlacesCache<P> placesCache;
+    public final DataFetcher<P> dataFetcher;
+
+
+    private CartoCacheConfig(Builder<P> builder) {
+        this.debug = builder.debug;
+        this.currentTileConfig = builder.currentTileConfig;
+        this.tileConfig = builder.tileConfig;
+
+        this.minDataFetchZoom = builder.minDataFetchZoom;
+        this.maxDataFetchZoom = builder.maxDataFetchZoom;
+        this.clusteringZoom = builder.clusteringZoom;
+        this.markerConfig = builder.markerConfig;
+        this.placesCache = builder.placesCache;
+        this.dataFetcher = builder.dataFetcher;
+    }
+
+}

.gradle/1.7/taskArtifacts/fileHashes.bin

@@ -0,0 +1,16 @@
+package com.codeandmagic.cartocache;
+
+import java.util.Collection;
+
+/**
+ * Created by evelyne24.
+ */
+public interface DataFetcher<P extends Place> {
+
+    public static interface Callback<P extends Place> {
+        void onSuccess(final QTile qTile, final Collection<P> places);
+        void onError(final QTile qTile, final Throwable e);
+    }
+
+    public void requestPlaces(final QTile qTile, final Callback<P> callback);
+}

.gradle/1.7/taskArtifacts/fileSnapshots.bin

@@ -0,0 +1,14 @@
+package com.codeandmagic.cartocache;
+
+import com.google.android.gms.maps.model.MarkerOptions;
+
+/**
+ * Created by evelyne24.
+ */
+public class DefaultMarkerConfig<P extends Place> implements MarkerConfig<P> {
+
+    @Override
+    public MarkerOptions getMarker(P place) {
+        return new MarkerOptions().position(place.getPosition()).title("Place " + place.getId());
+    }
+}