Merge pull request #289 from rsudev/master

Removed code that was only commented out in fix for #15

21 files changed, 357 insertions, 115 deletions

diff --git a/src/cgeo/geocaching/googlemaps/googleCacheOverlay.java b/src/cgeo/geocaching/googlemaps/googleCacheOverlay.java
index 68929cf..02e8c04 100644
--- a/src/cgeo/geocaching/googlemaps/googleCacheOverlay.java
+++ b/src/cgeo/geocaching/googlemaps/googleCacheOverlay.java
@@ -1,10 +1,12 @@
 package cgeo.geocaching.googlemaps;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Point;
 import android.graphics.drawable.Drawable;
-
 import cgeo.geocaching.cgSettings;
 import cgeo.geocaching.mapcommon.cgMapOverlay;
 import cgeo.geocaching.mapinterfaces.ItemizedOverlayImpl;
@@ -22,6 +24,7 @@ import com.google.android.maps.MapView;
 public class googleCacheOverlay extends ItemizedOverlay<googleCacheOverlayItem> implements ItemizedOverlayImpl {
 
 	private cgMapOverlay base;
+	private Lock lock = new ReentrantLock();
 
 	public googleCacheOverlay(cgSettings settingsIn, Context contextIn, Drawable markerIn, Boolean fromDetailIn) {
 		super(boundCenterBottom(markerIn));
@@ -98,4 +101,14 @@ public class googleCacheOverlay extends ItemizedOverlay<googleCacheOverlayItem>
 		// Nothing to do here...
 	}
 
+	@Override
+	public void lock() {
+		lock.lock();
+	}
+
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
+
 }
diff --git a/src/cgeo/geocaching/googlemaps/googleMapFactory.java b/src/cgeo/geocaching/googlemaps/googleMapFactory.java
index 28bfca5..ba62737 100644
--- a/src/cgeo/geocaching/googlemaps/googleMapFactory.java
+++ b/src/cgeo/geocaching/googlemaps/googleMapFactory.java
@@ -7,8 +7,6 @@ import cgeo.geocaching.cgUser;
 import cgeo.geocaching.mapinterfaces.CacheOverlayItemImpl;
 import cgeo.geocaching.mapinterfaces.GeoPointImpl;
 import cgeo.geocaching.mapinterfaces.MapFactory;
-import cgeo.geocaching.mapinterfaces.OverlayBase;
-import cgeo.geocaching.mapinterfaces.OverlayImpl;
 import cgeo.geocaching.mapinterfaces.UserOverlayItemImpl;
 
 import com.google.android.maps.MapActivity;
@@ -36,12 +34,6 @@ public class googleMapFactory implements MapFactory{
 	}
 
 	@Override
-	public OverlayImpl getOverlayBaseWrapper(OverlayBase ovlIn) {
-		googleOverlay baseOvl = new googleOverlay(ovlIn);
-		return baseOvl;
-	}
-
-	@Override
 	public CacheOverlayItemImpl getCacheOverlayItem(cgCoord coordinate, String type) {
 		googleCacheOverlayItem baseItem = new googleCacheOverlayItem(coordinate, type);
 		return baseItem;
diff --git a/src/cgeo/geocaching/googlemaps/googleMapView.java b/src/cgeo/geocaching/googlemaps/googleMapView.java
index 737e64e..6fa1eb7 100644
--- a/src/cgeo/geocaching/googlemaps/googleMapView.java
+++ b/src/cgeo/geocaching/googlemaps/googleMapView.java
@@ -1,18 +1,23 @@
 package cgeo.geocaching.googlemaps;
 
+import android.app.Activity;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
 import android.util.Log;
 import cgeo.geocaching.cgSettings;
+import cgeo.geocaching.mapcommon.cgMapMyOverlay;
 import cgeo.geocaching.mapcommon.cgMapOverlay;
+import cgeo.geocaching.mapcommon.cgOverlayScale;
 import cgeo.geocaching.mapcommon.cgUsersOverlay;
 import cgeo.geocaching.mapinterfaces.GeoPointImpl;
 import cgeo.geocaching.mapinterfaces.MapControllerImpl;
 import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
+import cgeo.geocaching.mapinterfaces.OverlayBase;
 import cgeo.geocaching.mapinterfaces.OverlayImpl;
+import cgeo.geocaching.mapinterfaces.OverlayImpl.overlayType;
 
 import com.google.android.maps.GeoPoint;
 import com.google.android.maps.MapView;
@@ -97,6 +102,24 @@ public class googleMapView extends MapView implements MapViewImpl{
 	}
 
 	@Override
+	public cgMapMyOverlay createAddPositionOverlay(Activity activity,
+			cgSettings settingsIn) {
+		
+		googleOverlay ovl = new googleOverlay(activity, settingsIn, overlayType.PositionOverlay);
+		getOverlays().add(ovl);
+		return (cgMapMyOverlay) ovl.getBase();
+	}
+
+	@Override
+	public cgOverlayScale createAddScaleOverlay(Activity activity,
+			cgSettings settingsIn) {
+
+		googleOverlay ovl = new googleOverlay(activity, settingsIn, overlayType.ScaleOverlay);
+		getOverlays().add(ovl);
+		return (cgOverlayScale) ovl.getBase();
+	}
+
+	@Override
 	public int getMapZoomLevel() {
 		return getZoomLevel();
 	}
@@ -105,14 +128,12 @@ public class googleMapView extends MapView implements MapViewImpl{
 	public void setMapSource(cgSettings settings) {
 
 		switch(settings.mapSource) {
-		case googleSat:
-			setSatellite(true);
-			break;
-		default:
-			setSatellite(false);
-	}
-
-
+			case googleSat:
+				setSatellite(true);
+				break;
+			default:
+				setSatellite(false);
+		}
 	}
 
 	@Override
@@ -124,4 +145,9 @@ public class googleMapView extends MapView implements MapViewImpl{
 	public void setBuiltinScale(boolean b) {
 		//Nothing to do for google maps...
 	}
+
+	@Override
+	public void repaintRequired(OverlayBase overlay) {
+		invalidate();
+	}
 }
diff --git a/src/cgeo/geocaching/googlemaps/googleOverlay.java b/src/cgeo/geocaching/googlemaps/googleOverlay.java
index 3847d9f..8473faa 100644
--- a/src/cgeo/geocaching/googlemaps/googleOverlay.java
+++ b/src/cgeo/geocaching/googlemaps/googleOverlay.java
@@ -1,6 +1,13 @@
 package cgeo.geocaching.googlemaps;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import android.app.Activity;
 import android.graphics.Canvas;
+import cgeo.geocaching.cgSettings;
+import cgeo.geocaching.mapcommon.cgMapMyOverlay;
+import cgeo.geocaching.mapcommon.cgOverlayScale;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
 import cgeo.geocaching.mapinterfaces.OverlayBase;
 import cgeo.geocaching.mapinterfaces.OverlayImpl;
@@ -10,17 +17,39 @@ import com.google.android.maps.Overlay;
 
 public class googleOverlay extends Overlay implements OverlayImpl {
 
-	private OverlayBase overlayBase;
+	private OverlayBase overlayBase = null;
+	private Lock lock = new ReentrantLock();
 	
-	public googleOverlay(OverlayBase overlayBaseIn) {
-		overlayBase = overlayBaseIn;
+	public googleOverlay(Activity activityIn, cgSettings settingsIn, overlayType ovlType) {
+		switch (ovlType) {
+			case PositionOverlay:
+				overlayBase = new cgMapMyOverlay(settingsIn, activityIn, this);
+				break;
+			case ScaleOverlay:
+				overlayBase = new cgOverlayScale(activityIn, settingsIn, this);
+		}
 	}
 	
 	@Override
 	public void draw(Canvas canvas, MapView mapView, boolean shadow) {
 		super.draw(canvas, mapView, shadow);
 		
-		overlayBase.draw(canvas, (MapViewImpl) mapView, shadow);
+		if (overlayBase != null) {
+			overlayBase.draw(canvas, (MapViewImpl) mapView, shadow);
+		}
+	}
+
+	public OverlayBase getBase() {
+		return overlayBase;
+	}
+
+	@Override
+	public void lock() {
+		lock.lock();
 	}
 
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
 }
diff --git a/src/cgeo/geocaching/googlemaps/googleUsersOverlay.java b/src/cgeo/geocaching/googlemaps/googleUsersOverlay.java
index 5019e6e..f5f16a7 100644
--- a/src/cgeo/geocaching/googlemaps/googleUsersOverlay.java
+++ b/src/cgeo/geocaching/googlemaps/googleUsersOverlay.java
@@ -1,5 +1,8 @@
 package cgeo.geocaching.googlemaps;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Point;
@@ -15,6 +18,7 @@ import com.google.android.maps.MapView;
 public class googleUsersOverlay extends ItemizedOverlay<googleUsersOverlayItem> implements ItemizedOverlayImpl {
 
 	private cgUsersOverlay base;
+	private Lock lock = new ReentrantLock();	
 
 	public googleUsersOverlay(Context contextIn, Drawable markerIn) {
 		super(boundCenter(markerIn));
@@ -91,4 +95,14 @@ public class googleUsersOverlay extends ItemizedOverlay<googleUsersOverlayItem>
 		// Nothing to do here
 	}
 
-}
\ No newline at end of file
+	@Override
+	public void lock() {
+		lock.lock();
+	}
+
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
+
+}
diff --git a/src/cgeo/geocaching/mapcommon/ItemizedOverlayBase.java b/src/cgeo/geocaching/mapcommon/ItemizedOverlayBase.java
index 41739e2..4e0379c 100644
--- a/src/cgeo/geocaching/mapcommon/ItemizedOverlayBase.java
+++ b/src/cgeo/geocaching/mapcommon/ItemizedOverlayBase.java
@@ -6,6 +6,8 @@ import android.graphics.drawable.Drawable;
 import cgeo.geocaching.mapinterfaces.ItemizedOverlayImpl;
 import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
+import cgeo.geocaching.mapinterfaces.OverlayBase;
+import cgeo.geocaching.mapinterfaces.OverlayImpl;
 import cgeo.geocaching.mapinterfaces.OverlayItemImpl;
 
 /**
@@ -14,7 +16,7 @@ import cgeo.geocaching.mapinterfaces.OverlayItemImpl;
  * @author rsudev
  *
  */
-public abstract class ItemizedOverlayBase {
+public abstract class ItemizedOverlayBase implements OverlayBase {
 	
 	private ItemizedOverlayImpl ovlImpl;
 
@@ -50,6 +52,11 @@ public abstract class ItemizedOverlayBase {
 			MapProjectionImpl projection, byte drawZoomLevel) {
 		ovlImpl.superDrawOverlayBitmap(canvas, drawPosition, projection, drawZoomLevel);
 	}
+	
+	@Override
+	public OverlayImpl getOverlayImpl() {
+		return ovlImpl;
+	}
 
 	public abstract OverlayItemImpl createItem(int index);
 	
diff --git a/src/cgeo/geocaching/mapcommon/cgMapMyOverlay.java b/src/cgeo/geocaching/mapcommon/cgMapMyOverlay.java
index cbf065c..b8c8723 100644
--- a/src/cgeo/geocaching/mapcommon/cgMapMyOverlay.java
+++ b/src/cgeo/geocaching/mapcommon/cgMapMyOverlay.java
@@ -6,10 +6,11 @@ import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
+import android.graphics.Matrix;
 import android.graphics.Paint;
-import android.graphics.Paint.Style;
 import android.graphics.PaintFlagsDrawFilter;
 import android.graphics.Point;
+import android.graphics.Paint.Style;
 import android.location.Location;
 import cgeo.geocaching.R;
 import cgeo.geocaching.cgBase;
@@ -19,6 +20,7 @@ import cgeo.geocaching.mapinterfaces.MapFactory;
 import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
 import cgeo.geocaching.mapinterfaces.OverlayBase;
+import cgeo.geocaching.mapinterfaces.OverlayImpl;
 
 public class cgMapMyOverlay implements OverlayBase {
 	private cgSettings settings = null;
@@ -31,8 +33,8 @@ public class cgMapMyOverlay implements OverlayBase {
 	private Point center = new Point();
 	private Point left = new Point();
 	private Bitmap arrow = null;
-	private int widthArrow = 0;
-	private int heightArrow = 0;
+	private int widthArrowHalf = 0;
+	private int heightArrowHalf = 0;
 	private PaintFlagsDrawFilter setfil = null;
 	private PaintFlagsDrawFilter remfil = null;
 	private Location historyRecent = null;
@@ -41,11 +43,13 @@ public class cgMapMyOverlay implements OverlayBase {
 	private Point historyPointP = new Point();
 	private Activity activity;
 	private MapFactory mapFactory = null;
+	private OverlayImpl ovlImpl = null;
 
-	public cgMapMyOverlay(cgSettings settingsIn, Activity activity) {
+	public cgMapMyOverlay(cgSettings settingsIn, Activity activity, OverlayImpl ovlImpl) {
 		settings = settingsIn;
 		this.activity = activity;
 		this.mapFactory = settings.getMapFactory();
+		this.ovlImpl = ovlImpl;
 	}
 
 	public void setCoordinates(Location coordinatesIn) {
@@ -184,22 +188,29 @@ public class cgMapMyOverlay implements OverlayBase {
 
 		if (arrow == null) {
 			arrow = BitmapFactory.decodeResource(activity.getResources(), R.drawable.my_location_chevron);
-			widthArrow = arrow.getWidth();
-			heightArrow = arrow.getHeight();
+			widthArrowHalf = arrow.getWidth() / 2;
+			heightArrowHalf = arrow.getHeight() / 2;
 		}
 
 		int marginLeft;
 		int marginTop;
 
-		marginLeft = center.x - (widthArrow / 2);
-		marginTop = center.y - (heightArrow / 2);
+		marginLeft = center.x - widthArrowHalf;
+		marginTop = center.y - heightArrowHalf;
+		
+		Matrix matrix = new Matrix();
+		matrix.setRotate(heading.floatValue(), widthArrowHalf, heightArrowHalf);
+		matrix.postTranslate(marginLeft, marginTop);
 
-		canvas.rotate(heading.floatValue(), center.x, center.y);
-		canvas.drawBitmap(arrow, marginLeft, marginTop, null);
-		canvas.rotate(-(heading.floatValue()), center.x, center.y);
+		canvas.drawBitmap(arrow, matrix, null);
 
 		canvas.setDrawFilter(remfil);
 
 		//super.draw(canvas, mapView, shadow);
 	}
+
+	@Override
+	public OverlayImpl getOverlayImpl() {
+		return this.ovlImpl;
+	}
 }
\ No newline at end of file
diff --git a/src/cgeo/geocaching/mapcommon/cgMapOverlay.java b/src/cgeo/geocaching/mapcommon/cgMapOverlay.java
index 80eba5a..d3f7c00 100644
--- a/src/cgeo/geocaching/mapcommon/cgMapOverlay.java
+++ b/src/cgeo/geocaching/mapcommon/cgMapOverlay.java
@@ -10,9 +10,9 @@ import android.content.Intent;
 import android.graphics.Canvas;
 import android.graphics.DashPathEffect;
 import android.graphics.Paint;
-import android.graphics.Paint.Style;
 import android.graphics.PaintFlagsDrawFilter;
 import android.graphics.Point;
+import android.graphics.Paint.Style;
 import android.location.Location;
 import android.text.Html;
 import android.util.Log;
@@ -74,10 +74,16 @@ public class cgMapOverlay extends ItemizedOverlayBase implements OverlayBase {
 			item.setMarker(boundCenterBottom(item.getMarker(0)));
 		}
 
-		items = new ArrayList<CacheOverlayItemImpl>(itemsPre);
-
-		setLastFocusedItemIndex(-1); // to reset tap during data change
-		populate();
+		// ensure no interference between the draw and content changing routines
+		getOverlayImpl().lock();
+		try {		
+			items = new ArrayList<CacheOverlayItemImpl>(itemsPre);
+	
+			setLastFocusedItemIndex(-1); // to reset tap during data change
+			populate();
+		} finally {
+			getOverlayImpl().unlock();
+		}
 	}
 
 	public boolean getCircles() {
@@ -107,51 +113,56 @@ public class cgMapOverlay extends ItemizedOverlayBase implements OverlayBase {
 
 	private void drawInternal(Canvas canvas, MapProjectionImpl projection) {
 
-		if (displayCircles) {
-			if (blockedCircle == null) {
-				blockedCircle = new Paint();
-				blockedCircle.setAntiAlias(true);
-				blockedCircle.setStrokeWidth(1.0f);
-				blockedCircle.setARGB(127, 0, 0, 0);
-				blockedCircle.setPathEffect(new DashPathEffect(new float[] {3,2}, 0));
-			}
-
-			if (setfil == null) setfil = new PaintFlagsDrawFilter(0, Paint.FILTER_BITMAP_FLAG);
-			if (remfil == null) remfil = new PaintFlagsDrawFilter(Paint.FILTER_BITMAP_FLAG, 0);
-
-			canvas.setDrawFilter(setfil);
-
-			for (CacheOverlayItemImpl item : items) {
-				final cgCoord itemCoord = item.getCoord();
-				float[] result = new float[1];
-
-				Location.distanceBetween(itemCoord.latitude, itemCoord.longitude, itemCoord.latitude, itemCoord.longitude + 1, result);
-				final float longitudeLineDistance = result[0];
-
-				GeoPointImpl itemGeo = mapFactory.getGeoPointBase((int)(itemCoord.latitude * 1e6), (int)(itemCoord.longitude * 1e6));
-				GeoPointImpl leftGeo = mapFactory.getGeoPointBase((int)(itemCoord.latitude * 1e6), (int)((itemCoord.longitude - 161 / longitudeLineDistance) * 1e6));
-
-				projection.toPixels(itemGeo, center);
-				projection.toPixels(leftGeo, left);
-				int radius = center.x - left.x;
-
-				final String type = item.getType();
-				if (type == null || "multi".equals(type) || "mystery".equals(type) || "virtual".equals(type)) {
-					blockedCircle.setColor(0x66000000);
-					blockedCircle.setStyle(Style.STROKE);
-					canvas.drawCircle(center.x, center.y, radius, blockedCircle);
-				} else {
-					blockedCircle.setColor(0x66BB0000);
-					blockedCircle.setStyle(Style.STROKE);
-					canvas.drawCircle(center.x, center.y, radius, blockedCircle);
-
-					blockedCircle.setColor(0x44BB0000);
-					blockedCircle.setStyle(Style.FILL);
-					canvas.drawCircle(center.x, center.y, radius, blockedCircle);
+		// prevent content changes
+		getOverlayImpl().lock();
+		try {
+			if (displayCircles) {
+				if (blockedCircle == null) {
+					blockedCircle = new Paint();
+					blockedCircle.setAntiAlias(true);
+					blockedCircle.setStrokeWidth(1.0f);
+					blockedCircle.setARGB(127, 0, 0, 0);
+					blockedCircle.setPathEffect(new DashPathEffect(new float[] {3,2}, 0));
 				}
+	
+				if (setfil == null) setfil = new PaintFlagsDrawFilter(0, Paint.FILTER_BITMAP_FLAG);
+				if (remfil == null) remfil = new PaintFlagsDrawFilter(Paint.FILTER_BITMAP_FLAG, 0);
+	
+				canvas.setDrawFilter(setfil);
+	
+				for (CacheOverlayItemImpl item : items) {
+					final cgCoord itemCoord = item.getCoord();
+					float[] result = new float[1];
+	
+					Location.distanceBetween(itemCoord.latitude, itemCoord.longitude, itemCoord.latitude, itemCoord.longitude + 1, result);
+					final float longitudeLineDistance = result[0];
+	
+					GeoPointImpl itemGeo = mapFactory.getGeoPointBase((int)(itemCoord.latitude * 1e6), (int)(itemCoord.longitude * 1e6));
+					GeoPointImpl leftGeo = mapFactory.getGeoPointBase((int)(itemCoord.latitude * 1e6), (int)((itemCoord.longitude - 161 / longitudeLineDistance) * 1e6));
+	
+					projection.toPixels(itemGeo, center);
+					projection.toPixels(leftGeo, left);
+					int radius = center.x - left.x;
+	
+					final String type = item.getType();
+					if (type == null || "multi".equals(type) || "mystery".equals(type) || "virtual".equals(type)) {
+						blockedCircle.setColor(0x66000000);
+						blockedCircle.setStyle(Style.STROKE);
+						canvas.drawCircle(center.x, center.y, radius, blockedCircle);
+					} else {
+						blockedCircle.setColor(0x66BB0000);
+						blockedCircle.setStyle(Style.STROKE);
+						canvas.drawCircle(center.x, center.y, radius, blockedCircle);
+	
+						blockedCircle.setColor(0x44BB0000);
+						blockedCircle.setStyle(Style.FILL);
+						canvas.drawCircle(center.x, center.y, radius, blockedCircle);
+					}
+				}	
+				canvas.setDrawFilter(remfil);
 			}
-
-			canvas.setDrawFilter(remfil);
+		} finally {
+			getOverlayImpl().unlock();
 		}
 	}
 
@@ -170,7 +181,22 @@ public class cgMapOverlay extends ItemizedOverlayBase implements OverlayBase {
 			}
 			waitDialog.show();
 
-			CacheOverlayItemImpl item = items.get(index);
+			CacheOverlayItemImpl item = null;
+			
+			// prevent concurrent changes
+			getOverlayImpl().lock();
+			try {				
+				 if (index < items.size()) {
+					 item = items.get(index);
+				 }
+			} finally {
+				getOverlayImpl().unlock();
+			}
+			
+			if (item == null) {
+				return false;
+			}
+			
 			cgCoord coordinate = item.getCoord();
 
 			if (coordinate.type != null && coordinate.type.equalsIgnoreCase("cache") && coordinate.geocode != null && coordinate.geocode.length() > 0) {
diff --git a/src/cgeo/geocaching/mapcommon/cgOverlayScale.java b/src/cgeo/geocaching/mapcommon/cgOverlayScale.java
index 4aae3d5..93de894 100644
--- a/src/cgeo/geocaching/mapcommon/cgOverlayScale.java
+++ b/src/cgeo/geocaching/mapcommon/cgOverlayScale.java
@@ -14,6 +14,7 @@ import cgeo.geocaching.mapinterfaces.GeoPointImpl;
 import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
 import cgeo.geocaching.mapinterfaces.OverlayBase;
+import cgeo.geocaching.mapinterfaces.OverlayImpl;
 
 public class cgOverlayScale implements OverlayBase {
 	private cgSettings settings = null;
@@ -26,9 +27,11 @@ public class cgOverlayScale implements OverlayBase {
 	private double distance = 0d;
 	private double distanceRound = 0d;
 	private String units = null;
+	private OverlayImpl ovlImpl=null;
 
-    public cgOverlayScale(Activity activity, cgSettings settingsIn) {
+    public cgOverlayScale(Activity activity, cgSettings settingsIn, OverlayImpl overlayImpl) {
 		settings = settingsIn;
+		this.ovlImpl = overlayImpl;
 
 		DisplayMetrics metrics = new DisplayMetrics();
 		activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
@@ -138,4 +141,9 @@ public class cgOverlayScale implements OverlayBase {
 		canvas.drawLine(10, bottom, (int)(pixels + 10), bottom, scale);
 		canvas.drawText(String.format("%.0f", distanceRound) + " " + units, (float)(pixels - (10 * pixelDensity)), (bottom - (10 * pixelDensity)), scale);
     }
-}
\ No newline at end of file
+
+	@Override
+	public OverlayImpl getOverlayImpl() {
+		return getOverlayImpl();
+	}
+}
diff --git a/src/cgeo/geocaching/mapcommon/cgeomap.java b/src/cgeo/geocaching/mapcommon/cgeomap.java
index 474b881..8500e1c 100644
--- a/src/cgeo/geocaching/mapcommon/cgeomap.java
+++ b/src/cgeo/geocaching/mapcommon/cgeomap.java
@@ -28,13 +28,13 @@ import cgeo.geocaching.cgCoord;
 import cgeo.geocaching.cgDirection;
 import cgeo.geocaching.cgGeo;
 import cgeo.geocaching.cgSettings;
-import cgeo.geocaching.cgSettings.mapSourceEnum;
 import cgeo.geocaching.cgUpdateDir;
 import cgeo.geocaching.cgUpdateLoc;
 import cgeo.geocaching.cgUser;
 import cgeo.geocaching.cgWaypoint;
 import cgeo.geocaching.cgeoapplication;
 import cgeo.geocaching.activity.ActivityMixin;
+import cgeo.geocaching.cgSettings.mapSourceEnum;
 import cgeo.geocaching.mapinterfaces.ActivityImpl;
 import cgeo.geocaching.mapinterfaces.CacheOverlayItemImpl;
 import cgeo.geocaching.mapinterfaces.GeoPointImpl;
@@ -269,8 +269,7 @@ public class cgeomap extends MapBase {
 		mapView.clearOverlays();
 
 		if (overlayMyLoc == null) {
-			overlayMyLoc = new cgMapMyOverlay(settings, activity);
-			mapView.addOverlay(mapFactory.getOverlayBaseWrapper(overlayMyLoc));
+			overlayMyLoc = mapView.createAddPositionOverlay(activity, settings);
 		}
 
 		if (settings.publicLoc > 0 && overlayUsers == null) {
@@ -282,8 +281,7 @@ public class cgeomap extends MapBase {
 		}
 
 		if (overlayScale == null && mapView.needsScaleOverlay()) {
-			overlayScale = new cgOverlayScale(activity, settings);
-			mapView.addOverlay(mapFactory.getOverlayBaseWrapper(overlayScale));
+			overlayScale = mapView.createAddScaleOverlay(activity, settings);
 		}
 
 		mapView.invalidate();
@@ -747,9 +745,10 @@ public class cgeomap extends MapBase {
 			}
 
 			try {
+				boolean repaintRequired = false;
+				
 				if (overlayMyLoc == null && mapView != null) {
-					overlayMyLoc = new cgMapMyOverlay(settings, activity);
-					mapView.addOverlay(settings.getMapFactory().getOverlayBaseWrapper(overlayMyLoc));
+					overlayMyLoc = mapView.createAddPositionOverlay(activity, settings);
 				}
 
 				if (overlayMyLoc != null && geo.location != null) {
@@ -760,8 +759,7 @@ public class cgeomap extends MapBase {
 					if (followMyLocation) {
 						myLocationInMiddle();
 					} else {
-						// move blue arrow
-						mapView.invalidate();
+						repaintRequired = true;
 					}
 				}
 
@@ -771,7 +769,13 @@ public class cgeomap extends MapBase {
 					} else {
 						overlayMyLoc.setHeading(Double.valueOf(0));
 					}
+					repaintRequired = true;
+				}
+				
+				if (repaintRequired) {
+					mapView.repaintRequired(overlayMyLoc);
 				}
+				
 			} catch (Exception e) {
 				Log.w(cgSettings.tag, "Failed to update location.");
 			}
diff --git a/src/cgeo/geocaching/mapinterfaces/ItemizedOverlayImpl.java b/src/cgeo/geocaching/mapinterfaces/ItemizedOverlayImpl.java
index 73eed1f..08e28ad 100644
--- a/src/cgeo/geocaching/mapinterfaces/ItemizedOverlayImpl.java
+++ b/src/cgeo/geocaching/mapinterfaces/ItemizedOverlayImpl.java
@@ -1,9 +1,9 @@
 package cgeo.geocaching.mapinterfaces;
 
-import cgeo.geocaching.mapcommon.ItemizedOverlayBase;
 import android.graphics.Canvas;
 import android.graphics.Point;
 import android.graphics.drawable.Drawable;
+import cgeo.geocaching.mapcommon.ItemizedOverlayBase;
 
 /**
  * Defines the common functions to access the provider-specific
@@ -11,7 +11,7 @@ import android.graphics.drawable.Drawable;
  * @author rsudev
  *
  */
-public interface ItemizedOverlayImpl {
+public interface ItemizedOverlayImpl extends OverlayImpl {
 
 	ItemizedOverlayBase getBase();
 
diff --git a/src/cgeo/geocaching/mapinterfaces/MapFactory.java b/src/cgeo/geocaching/mapinterfaces/MapFactory.java
index 620f673..4348c40 100644
--- a/src/cgeo/geocaching/mapinterfaces/MapFactory.java
+++ b/src/cgeo/geocaching/mapinterfaces/MapFactory.java
@@ -21,8 +21,6 @@ public interface MapFactory {
 
 	public GeoPointImpl getGeoPointBase(int latE6, int lonE6);
 
-	public OverlayImpl getOverlayBaseWrapper(OverlayBase ovlIn);
-
 	CacheOverlayItemImpl getCacheOverlayItem(cgCoord coordinate, String type);
 
 	public UserOverlayItemImpl getUserOverlayItemBase(Context context,
diff --git a/src/cgeo/geocaching/mapinterfaces/MapViewImpl.java b/src/cgeo/geocaching/mapinterfaces/MapViewImpl.java
index 5c955ed..8e99b3d 100644
--- a/src/cgeo/geocaching/mapinterfaces/MapViewImpl.java
+++ b/src/cgeo/geocaching/mapinterfaces/MapViewImpl.java
@@ -1,10 +1,13 @@
 package cgeo.geocaching.mapinterfaces;
 
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.drawable.Drawable;
 import cgeo.geocaching.cgSettings;
+import cgeo.geocaching.mapcommon.cgMapMyOverlay;
 import cgeo.geocaching.mapcommon.cgMapOverlay;
+import cgeo.geocaching.mapcommon.cgOverlayScale;
 import cgeo.geocaching.mapcommon.cgUsersOverlay;
-import android.content.Context;
-import android.graphics.drawable.Drawable;
 
 /**
  * Defines common functions of the provider-specific
@@ -50,6 +53,10 @@ public interface MapViewImpl {
 			Drawable drawable, boolean fromDetailIntent);
 
 	cgUsersOverlay createAddUsersOverlay(Context context, Drawable markerIn);
+	
+	cgOverlayScale createAddScaleOverlay(Activity activity, cgSettings settingsIn);
+
+	cgMapMyOverlay createAddPositionOverlay(Activity activity, cgSettings settingsIn);
 
 	boolean needsScaleOverlay();
 
@@ -57,4 +64,6 @@ public interface MapViewImpl {
 
 	void setMapSource(cgSettings settings);
 
+	void repaintRequired(OverlayBase overlay);
+
 }
diff --git a/src/cgeo/geocaching/mapinterfaces/OverlayBase.java b/src/cgeo/geocaching/mapinterfaces/OverlayBase.java
index 59afb49..17a4d85 100644
--- a/src/cgeo/geocaching/mapinterfaces/OverlayBase.java
+++ b/src/cgeo/geocaching/mapinterfaces/OverlayBase.java
@@ -16,4 +16,5 @@ public interface OverlayBase {
 	void drawOverlayBitmap(Canvas canvas, Point drawPosition,
 			MapProjectionImpl projection, byte drawZoomLevel);
 
+	OverlayImpl getOverlayImpl();
 }
diff --git a/src/cgeo/geocaching/mapinterfaces/OverlayImpl.java b/src/cgeo/geocaching/mapinterfaces/OverlayImpl.java
index 6680b6a..ba45532 100644
--- a/src/cgeo/geocaching/mapinterfaces/OverlayImpl.java
+++ b/src/cgeo/geocaching/mapinterfaces/OverlayImpl.java
@@ -8,4 +8,13 @@ package cgeo.geocaching.mapinterfaces;
  */
 public interface OverlayImpl {
 
+	public enum overlayType {
+		PositionOverlay,
+		ScaleOverlay
+	}
+
+	void lock();
+
+	void unlock();
+	
 }
diff --git a/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java b/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java
index 6333133..1e3b287 100644
--- a/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java
+++ b/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java
@@ -1,5 +1,8 @@
 package cgeo.geocaching.mapsforge;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import org.mapsforge.android.maps.ItemizedOverlay;
 import org.mapsforge.android.maps.Projection;
 
@@ -17,6 +20,7 @@ import cgeo.geocaching.mapinterfaces.MapViewImpl;
 public class mfCacheOverlay extends ItemizedOverlay<mfCacheOverlayItem> implements ItemizedOverlayImpl {
 
 	private cgMapOverlay base;
+	private Lock lock = new ReentrantLock();
 
 	public mfCacheOverlay(cgSettings settingsIn, Context contextIn, Drawable markerIn, Boolean fromDetailIn) {
 		super(boundCenterBottom(markerIn));
@@ -94,5 +98,15 @@ public class mfCacheOverlay extends ItemizedOverlay<mfCacheOverlayItem> implemen
 		super.drawOverlayBitmap(canvas, drawPosition, (Projection) projection.getImpl(), drawZoomLevel);
 	}
 
+	@Override
+	public void lock() {
+		lock.lock();
+	}
+
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
+
 }
 
diff --git a/src/cgeo/geocaching/mapsforge/mfMapController.java b/src/cgeo/geocaching/mapsforge/mfMapController.java
index 45efef2..932e640 100644
--- a/src/cgeo/geocaching/mapsforge/mfMapController.java
+++ b/src/cgeo/geocaching/mapsforge/mfMapController.java
@@ -9,9 +9,11 @@ import cgeo.geocaching.mapinterfaces.MapControllerImpl;
 public class mfMapController implements MapControllerImpl {
 
 	private MapController mapController;
+	private int maxZoomLevel;
 	
-	public mfMapController(MapController mapControllerIn) {
+	public mfMapController(MapController mapControllerIn, int maxZoomLevelIn) {
 		mapController = mapControllerIn;
+		maxZoomLevel = maxZoomLevelIn;
 	}
 
 	@Override
@@ -26,7 +28,11 @@ public class mfMapController implements MapControllerImpl {
 
 	@Override
 	public void setZoom(int mapzoom) {
-		mapController.setZoom(mapzoom-1);
+		int mfzoom = mapzoom-1;
+		if (mfzoom > maxZoomLevel) {
+			mfzoom = maxZoomLevel;
+		}
+		mapController.setZoom(mfzoom);
 	}
 
 	@Override
diff --git a/src/cgeo/geocaching/mapsforge/mfMapFactory.java b/src/cgeo/geocaching/mapsforge/mfMapFactory.java
index fa665ec..00204dd 100644
--- a/src/cgeo/geocaching/mapsforge/mfMapFactory.java
+++ b/src/cgeo/geocaching/mapsforge/mfMapFactory.java
@@ -8,8 +8,6 @@ import cgeo.geocaching.cgUser;
 import cgeo.geocaching.mapinterfaces.CacheOverlayItemImpl;
 import cgeo.geocaching.mapinterfaces.GeoPointImpl;
 import cgeo.geocaching.mapinterfaces.MapFactory;
-import cgeo.geocaching.mapinterfaces.OverlayBase;
-import cgeo.geocaching.mapinterfaces.OverlayImpl;
 import cgeo.geocaching.mapinterfaces.UserOverlayItemImpl;
 
 public class mfMapFactory implements MapFactory{
@@ -35,12 +33,6 @@ public class mfMapFactory implements MapFactory{
 	}
 
 	@Override
-	public OverlayImpl getOverlayBaseWrapper(OverlayBase ovlIn) {
-		mfOverlay baseOvl = new mfOverlay(ovlIn);
-		return baseOvl;
-	}
-
-	@Override
 	public CacheOverlayItemImpl getCacheOverlayItem(cgCoord coordinate, String type) {
 		mfCacheOverlayItem baseItem = new mfCacheOverlayItem(coordinate, type);
 		return baseItem;
diff --git a/src/cgeo/geocaching/mapsforge/mfMapView.java b/src/cgeo/geocaching/mapsforge/mfMapView.java
index de4bd1a..1e83f33 100644
--- a/src/cgeo/geocaching/mapsforge/mfMapView.java
+++ b/src/cgeo/geocaching/mapsforge/mfMapView.java
@@ -7,19 +7,24 @@ import org.mapsforge.android.maps.MapViewMode;
 import org.mapsforge.android.maps.Overlay;
 import org.mapsforge.android.maps.Projection;
 
+import android.app.Activity;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
 import android.util.Log;
 import cgeo.geocaching.cgSettings;
+import cgeo.geocaching.mapcommon.cgMapMyOverlay;
 import cgeo.geocaching.mapcommon.cgMapOverlay;
+import cgeo.geocaching.mapcommon.cgOverlayScale;
 import cgeo.geocaching.mapcommon.cgUsersOverlay;
 import cgeo.geocaching.mapinterfaces.GeoPointImpl;
 import cgeo.geocaching.mapinterfaces.MapControllerImpl;
 import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
 import cgeo.geocaching.mapinterfaces.MapViewImpl;
+import cgeo.geocaching.mapinterfaces.OverlayBase;
 import cgeo.geocaching.mapinterfaces.OverlayImpl;
+import cgeo.geocaching.mapinterfaces.OverlayImpl.overlayType;
 
 public class mfMapView extends MapView implements MapViewImpl {
 
@@ -47,7 +52,7 @@ public class mfMapView extends MapView implements MapViewImpl {
 
 	@Override
 	public MapControllerImpl getMapController() {
-		return new mfMapController(getController());
+		return new mfMapController(getController(), getMaxZoomLevel());
 	}
 
 	@Override
@@ -88,6 +93,22 @@ public class mfMapView extends MapView implements MapViewImpl {
 	}
 
 	@Override
+	public cgMapMyOverlay createAddPositionOverlay(Activity activity,
+			cgSettings settingsIn) {
+		mfOverlay ovl = new mfOverlay(activity, settingsIn, overlayType.PositionOverlay);
+		getOverlays().add(ovl);
+		return (cgMapMyOverlay) ovl.getBase();
+	}
+
+	@Override
+	public cgOverlayScale createAddScaleOverlay(Activity activity,
+			cgSettings settingsIn) {
+		mfOverlay ovl = new mfOverlay(activity, settingsIn, overlayType.ScaleOverlay);
+		getOverlays().add(ovl);
+		return (cgOverlayScale) ovl.getBase();
+	}	
+
+	@Override
 	public int getLatitudeSpan() {
 		
 		int span = 0;
@@ -160,10 +181,28 @@ public class mfMapView extends MapView implements MapViewImpl {
 				if (MapDatabase.isValidMapFile(settings.getMapFile())) {
 					setMapViewMode(MapViewMode.CANVAS_RENDERER);
 					super.setMapFile(settings.getMapFile());
+				} else {
+					setMapViewMode(MapViewMode.MAPNIK_TILE_DOWNLOAD);
 				}
 				break;
 			default:
 				setMapViewMode(MapViewMode.MAPNIK_TILE_DOWNLOAD);
 		}
 	}
+
+	@Override
+	public void repaintRequired(OverlayBase overlay) {
+		
+		try {
+			mfOverlay ovl = (mfOverlay) overlay.getOverlayImpl();
+			
+			if (ovl != null) {
+				ovl.requestRedraw();
+			}
+			
+		} catch (Exception e) {
+			Log.e(cgSettings.tag, "mfMapView.repaintRequired: " + e.toString());
+		}
+	}
+
 }
diff --git a/src/cgeo/geocaching/mapsforge/mfOverlay.java b/src/cgeo/geocaching/mapsforge/mfOverlay.java
index e015307..f764c6b 100644
--- a/src/cgeo/geocaching/mapsforge/mfOverlay.java
+++ b/src/cgeo/geocaching/mapsforge/mfOverlay.java
@@ -1,26 +1,56 @@
 package cgeo.geocaching.mapsforge;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import org.mapsforge.android.maps.Overlay;
 import org.mapsforge.android.maps.Projection;
 
+import android.app.Activity;
 import android.graphics.Canvas;
 import android.graphics.Point;
+import cgeo.geocaching.cgSettings;
+import cgeo.geocaching.mapcommon.cgMapMyOverlay;
+import cgeo.geocaching.mapcommon.cgOverlayScale;
 import cgeo.geocaching.mapinterfaces.OverlayBase;
 import cgeo.geocaching.mapinterfaces.OverlayImpl;
 
 public class mfOverlay extends Overlay implements OverlayImpl {
 
-	private OverlayBase overlayBase;
+	private OverlayBase overlayBase = null;
+	private Lock lock = new ReentrantLock();
 	
-	public mfOverlay(OverlayBase overlayBaseIn) {
-		overlayBase = overlayBaseIn;
+	public mfOverlay(Activity activityIn, cgSettings settingsIn, OverlayImpl.overlayType ovlType) {
+		
+		switch (ovlType) {
+			case PositionOverlay:
+				overlayBase = new cgMapMyOverlay(settingsIn, activityIn, this);
+				break;
+			case ScaleOverlay:
+				overlayBase = new cgOverlayScale(activityIn, settingsIn, this);
+		}
 	}
 	
 	@Override
 	protected void drawOverlayBitmap(Canvas canvas, Point drawPosition,
 			Projection projection, byte drawZoomLevel) {
 		
-		overlayBase.drawOverlayBitmap(canvas, drawPosition, new mfMapProjection(projection), drawZoomLevel);
+		if (overlayBase != null) {
+			overlayBase.drawOverlayBitmap(canvas, drawPosition, new mfMapProjection(projection), drawZoomLevel);
+		}
 	}
 
+	public OverlayBase getBase() {
+		return overlayBase;
+	}
+
+	@Override
+	public void lock() {
+		lock.lock();
+	}
+
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
 }
diff --git a/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java b/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java
index 8f3ba04..6e2819c 100644
--- a/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java
+++ b/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java
@@ -1,5 +1,8 @@
 package cgeo.geocaching.mapsforge;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import org.mapsforge.android.maps.ItemizedOverlay;
 import org.mapsforge.android.maps.Projection;
 
@@ -15,6 +18,7 @@ import cgeo.geocaching.mapinterfaces.MapViewImpl;
 public class mfUsersOverlay extends ItemizedOverlay<mfUsersOverlayItem> implements ItemizedOverlayImpl {
 
 	private cgUsersOverlay base;
+	private Lock lock = new ReentrantLock();
 
 	public mfUsersOverlay(Context contextIn, Drawable markerIn) {
 		super(boundCenter(markerIn));
@@ -94,4 +98,14 @@ public class mfUsersOverlay extends ItemizedOverlay<mfUsersOverlayItem> implemen
 		super.drawOverlayBitmap(canvas, drawPosition, (Projection) projection.getImpl(), drawZoomLevel);
 	}
 
+	@Override
+	public void lock() {
+		lock.lock();
+	}
+
+	@Override
+	public void unlock() {
+		lock.unlock();
+	}
+
 }
\ No newline at end of file