Merge pull request jimburton#35 from AlmasB/cache_branch

I've done some testing and this looks good. I'm going to use it as an example (with a namecheck of course) in a lecture on Android optimisation. Thanks.

Author: jimburton

src/uk/ac/brighton/ci360/bigarrow/Cache.java

@@ -0,0 +1,136 @@
+package uk.ac.brighton.ci360.bigarrow;
+
+import java.util.LinkedList;
+import java.util.WeakHashMap;
+
+/**
+ * This class saves information about searches
+ * so that same search instead of loading data over network
+ * will read it from memory
+ * 
+ * Copyright (c) 2013 The BigArrow authors (see the file AUTHORS).
+ * See the file LICENSE for copying permission.
+ * 
+ * @author Almas Baimagambetov (ab607)
+ * 
+ */
+public class Cache<V extends Cacheable> {
+
+    /**
+     * Maximum number of key-value mappings that can be held in cache
+     * This value is used by default when the limit is not specified
+     */
+    private static final int DEFAULT_CACHE_SIZE_LIMIT = 30;
+    
+    /**
+     * Maximum number of key-value mappings that can be held in this cache
+     */
+    private int sizeLimit;
+    
+    /**
+     * Formatter used to format cache keys
+     */
+    private Formatter formatter;
+    
+    /**
+     * Actual key and value "holder"
+     */
+    private WeakHashMap<String, V> cache;
+    
+    /**
+     * Provides means of identifying the least-recently accessed cache item
+     * 
+     * First (head) element of this queue is the key
+     * of the least-recently cached entry
+     */
+    private LinkedList<String> queue = new LinkedList<String>();
+    
+    /**
+     * Constructs cache with given formatter
+     * and default size limit
+     * 
+     * @param formatter
+     */
+    public Cache(Formatter formatter) {
+        this(DEFAULT_CACHE_SIZE_LIMIT, formatter);
+    }
+    
+    /**
+     * Constructs cache with given formatter
+     * and given size limit, also taking into
+     * account the default load factor of 7500 (0.75)
+     * 
+     * @param limit
+     * @param formatter
+     */
+    public Cache(int limit, Formatter formatter) {
+        sizeLimit = limit;
+        this.formatter = formatter;
+        cache = new WeakHashMap<String, V>((int)(sizeLimit/0.75) + 1);
+    }
+
+    /**
+     * Maps the specified key to the specified value
+     *
+     * @param key
+     * @param value
+     */
+    public void store(String key, V value) {
+        key = formatter.formatKey(key);
+        if (queue.size() == sizeLimit) {
+            cache.remove(queue.poll());
+        }
+        
+        queue.add(key);
+        cache.put(key, value);
+    }
+    
+    /**
+     * Retrieve the value of the mapping with the specified key
+     *
+     * @param key
+     * @return the value of the mapping with the specified key, or {@code null}
+     *         if no mapping for the specified key is found
+     */
+    public V get(String key) {
+        key = formatter.formatKey(key);
+        queue.remove(key);
+        queue.add(key);
+        return cache.get(key);
+    }
+    
+    /**
+     * Returns whether this cache contains the specified key
+     *
+     * @param key the key to search for
+     * @return {@code true} if this map contains the specified key,
+     *         {@code false} otherwise
+     */
+    public boolean contains(String key) {
+        return cache.containsKey(formatter.formatKey(key));
+    }
+    
+    /**
+     * @return number of items currently held in cache
+     */
+    public int getSize() {
+        return cache.size();
+    }
+    
+    /**
+     * @return maximum number of items that can be held in this cache
+     */
+    public int getLimit() {
+        return sizeLimit;
+    }
+    
+    /**
+     * Removes all data held in cache
+     * Consequently on the first following GC sweep
+     * GC will attempt to free up the memory used by old objects
+     */
+    public void free() {
+        queue.clear();
+        cache.clear();
+    }
+}

src/uk/ac/brighton/ci360/bigarrow/Cacheable.java

@@ -0,0 +1,13 @@
+package uk.ac.brighton.ci360.bigarrow;
+
+/**
+ * Brings a little bit of structure to Cache
+ * 
+ * Copyright (c) 2013 The BigArrow authors (see the file AUTHORS).
+ * See the file LICENSE for copying permission.
+ * 
+ * @author Almas Baimagambetov (ab607)
+ */
+public interface Cacheable {
+
+}

src/uk/ac/brighton/ci360/bigarrow/Formatter.java

@@ -0,0 +1,24 @@
+package uk.ac.brighton.ci360.bigarrow;
+
+/**
+ * Users may use this interface to format cache
+ * keys appropriately
+ * 
+ * Copyright (c) 2013 The BigArrow authors (see the file AUTHORS).
+ * See the file LICENSE for copying permission.
+ * 
+ * @author Almas Baimagambetov (ab607)
+ */
+public interface Formatter {
+    
+    /**
+     * Used by {@code Cache} to format reference keys
+     * to cached objects
+     * 
+     * @param key
+     *            raw key
+     * @return
+     *          formatted key
+     */
+    public String formatKey(String key);
+}

src/uk/ac/brighton/ci360/bigarrow/PlacesAPISearch.java

@@ -86,10 +86,37 @@ public class PlacesAPISearch {
 	private CopyOnWriteArrayList<Bitmap> photoResults;
 
 	private ExecutorService executorService;
+	
+	private Cache<PlacesList> placesListCache;
+	private Cache<PlaceDetails> placeDetailsCache;
 
 	public PlacesAPISearch(PlaceSearchRequester requester) {
 		this.requester = requester;
 		Properties prop = new Properties();
+		
+		placesListCache = new Cache<PlacesList>(new Formatter() {
+		    @Override
+		    public String formatKey(String queryString) {
+		        String location = queryString.substring(queryString.indexOf("location=")+9);
+		        location = location.substring(0, location.indexOf("&"));
+		        String lat = location.substring(0, location.indexOf(","));
+		        String lng = location.substring(location.indexOf(",") + 1);
+		        
+		        lat = String.format("%.3f", Double.parseDouble(lat));
+		        lng = String.format("%.3f", Double.parseDouble(lng));
+		        
+		        String type = queryString.substring(queryString.indexOf("types=")+6);
+		        // "type1,type2&latitude,longitude"
+		        return type + "&" + lat + "," + lng;
+		    }
+		});
+		
+		placeDetailsCache = new Cache<PlaceDetails>(new Formatter() {
+		    @Override
+		    public String formatKey(String key) {
+		        return key.substring(key.indexOf("reference=") + 10, key.indexOf("&sensor"));
+		    }
+		});
 
 		try {
 			prop.load(PlacesAPISearch.class.getClassLoader()
@@ -142,10 +169,23 @@ protected PlacesList doInBackground(String... urls) {
 				request.getUrl().put("sensor", "true");
 				if (estabType != null)
 					request.getUrl().put("types", estabType.toLowerCase());
-				Log.d(TAG, request.getUrl().toString());
-				places = request.execute().parseAs(PlacesList.class);
+				
+				String query = request.getUrl().toString();
+				Log.d(TAG, query);
+				
+				if (placesListCache.contains(query)) {
+				    places = placesListCache.get(query);
+				    Log.d(TAG, "retrieved from cache");
+				}
+				else {
+				    places = request.execute().parseAs(PlacesList.class);
+				    // we really should do some data validation before storing
+	                placesListCache.store(query, places);
+				}
+
 				// Check log cat for places response status
 				Log.d(TAG, "" + places.status);
+
 				return places;
 			} catch (HttpResponseException e) {
 				Log.e("Error:", e.getMessage());
@@ -197,10 +237,23 @@ protected PlaceDetails doInBackground(String... urls) {
 				request.getUrl().put("key", apiKey);
 				request.getUrl().put("reference", detailsReference);
 				request.getUrl().put("sensor", "true");
-				Log.d(TAG, request.getUrl().toString());
-				details = request.execute().parseAs(PlaceDetails.class);
-				// Check log cat for places response status
-				Log.d(TAG, "" + details.status);
+				
+				String query = request.getUrl().toString();
+                Log.d(TAG, query);
+                
+                if (placeDetailsCache.contains(query)) {
+                    details = placeDetailsCache.get(query);
+                    Log.d(TAG, "retrieved from cache");
+                }
+                else {
+                    details = request.execute().parseAs(PlaceDetails.class);
+                    // we really should do some data validation before storing
+                    placeDetailsCache.store(query, details);
+                }
+				
+                // Check log cat for places response status
+                Log.d(TAG, "" + details.status);
+				
 				return details;
 			} catch (HttpResponseException e) {
 				Log.e("Error:", e.getMessage());

src/uk/ac/brighton/ci360/bigarrow/places/Place.java

@@ -9,7 +9,6 @@
  **/
 
 import java.io.Serializable;
-import java.util.Calendar;
 import java.util.LinkedHashMap;
 
 import android.annotation.SuppressLint;

src/uk/ac/brighton/ci360/bigarrow/places/PlaceDetails.java

@@ -9,9 +9,11 @@
  **/
 import java.io.Serializable;
 
+import uk.ac.brighton.ci360.bigarrow.Cacheable;
+
 import com.google.api.client.util.Key;
 
-public class PlaceDetails implements Serializable {
+public class PlaceDetails implements Serializable, Cacheable {
 
 	private static final long serialVersionUID = 1L;
 

src/uk/ac/brighton/ci360/bigarrow/places/PlacesList.java

@@ -9,10 +9,12 @@
  **/
 import java.io.Serializable;
 import java.util.List;
+
+import uk.ac.brighton.ci360.bigarrow.Cacheable;
 
 import com.google.api.client.util.Key;
 
-public class PlacesList implements Serializable {
+public class PlacesList implements Serializable, Cacheable {
 
     /**
 	 * 
@@ -24,5 +26,4 @@ public class PlacesList implements Serializable {
 
     @Key
     public List<Place> results;
- 
 }