First commit

11 files changed, 693 insertions, 0 deletions

diff --git a/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java b/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java
new file mode 100644
index 0000000..a7665cb
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfCacheOverlay.java
@@ -0,0 +1,99 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.ItemizedOverlay;
+import org.mapsforge.android.maps.MapView;
+import org.mapsforge.android.maps.Projection;
+
+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;
+import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
+import cgeo.geocaching.mapinterfaces.MapViewImpl;
+
+
+public class mfCacheOverlay extends ItemizedOverlay<mfCacheOverlayItem> implements ItemizedOverlayImpl {
+
+	private cgMapOverlay base;
+
+	public mfCacheOverlay(cgSettings settingsIn, Context contextIn, Drawable markerIn, Boolean fromDetailIn) {
+		super(boundCenterBottom(markerIn));
+		base = new cgMapOverlay(settingsIn, this, contextIn, fromDetailIn);
+	}
+	
+	@Override
+	public cgMapOverlay getBase() {
+		return base;
+	}
+
+	@Override
+	protected mfCacheOverlayItem createItem(int i) {
+		if (base == null)
+			return null;
+
+		return (mfCacheOverlayItem) base.createItem(i);
+	}
+
+	@Override
+	public int size() {
+		if (base == null)
+			return 0;
+
+		return base.size();
+	}
+
+	@Override
+	protected boolean onTap(int arg0) {
+		if (base == null)
+			return false;
+		
+		return base.onTap(arg0);
+	}
+
+	@Override
+	protected void drawOverlayBitmap(Canvas canvas, Point drawPosition,
+			Projection projection, byte drawZoomLevel) {
+		base.drawOverlayBitmap(canvas, drawPosition, new mfMapProjection(projection), drawZoomLevel);
+	}
+	
+	@Override
+	public void superPopulate() {
+		populate();
+	}
+
+	@Override
+	public Drawable superBoundCenter(Drawable markerIn) {
+		return super.boundCenter(markerIn);
+	}
+
+	@Override
+	public Drawable superBoundCenterBottom(Drawable marker) {
+		return super.boundCenterBottom(marker);
+	}
+
+	@Override
+	public void superSetLastFocusedItemIndex(int i) {
+		// nothing to do
+	}
+
+	@Override
+	public boolean superOnTap(int index) {
+		return super.onTap(index);
+	}
+
+	@Override
+	public void superDraw(Canvas canvas, MapViewImpl mapView, boolean shadow) {
+		// nothing to do here...
+	}
+
+	@Override
+	public void superDrawOverlayBitmap(Canvas canvas, Point drawPosition,
+			MapProjectionImpl projection, byte drawZoomLevel) {
+		super.drawOverlayBitmap(canvas, drawPosition, (Projection) projection.getImpl(), drawZoomLevel);
+	}
+
+}
+
diff --git a/src/cgeo/geocaching/mapsforge/mfCacheOverlayItem.java b/src/cgeo/geocaching/mapsforge/mfCacheOverlayItem.java
new file mode 100644
index 0000000..b6b7d62
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfCacheOverlayItem.java
@@ -0,0 +1,35 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+import org.mapsforge.android.maps.OverlayItem;
+
+import android.graphics.drawable.Drawable;
+
+import cgeo.geocaching.cgCoord;
+import cgeo.geocaching.mapinterfaces.CacheOverlayItemImpl;
+
+public class mfCacheOverlayItem extends OverlayItem implements CacheOverlayItemImpl {
+	private String cacheType = null;
+	private cgCoord coord;
+
+	public mfCacheOverlayItem(cgCoord coordinate, String type) {
+		super(new GeoPoint((int)(coordinate.latitude * 1e6), (int)(coordinate.longitude * 1e6)), coordinate.name, "");
+
+		this.cacheType = type;
+		this.coord = coordinate;
+	}
+	
+	public cgCoord getCoord() {
+		return coord;
+	}
+
+	public String getType() {
+		return cacheType;
+	}
+
+	@Override
+	public Drawable getMarker(int index) {
+		return getMarker();
+	}
+
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfGeoPoint.java b/src/cgeo/geocaching/mapsforge/mfGeoPoint.java
new file mode 100644
index 0000000..1261887
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfGeoPoint.java
@@ -0,0 +1,12 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+
+import cgeo.geocaching.mapinterfaces.GeoPointImpl;
+
+public class mfGeoPoint extends GeoPoint implements GeoPointImpl {
+
+	public mfGeoPoint(int latitudeE6, int longitudeE6) {
+		super(latitudeE6, longitudeE6);
+	}
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfMapActivity.java b/src/cgeo/geocaching/mapsforge/mfMapActivity.java
new file mode 100644
index 0000000..b878def
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfMapActivity.java
@@ -0,0 +1,96 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.MapActivity;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
+import cgeo.geocaching.mapcommon.MapBase;
+import cgeo.geocaching.mapcommon.cgeomap;
+import cgeo.geocaching.mapinterfaces.ActivityImpl;
+
+
+public class mfMapActivity extends MapActivity implements ActivityImpl {
+
+	private MapBase mapBase;
+	
+	public mfMapActivity() {
+		mapBase = new cgeomap(this);
+	}
+	
+	@Override
+	public Activity getActivity() {
+		return this;
+	}
+	
+	@Override
+	protected void onCreate(Bundle icicle) {
+		mapBase.onCreate(icicle);
+	}
+
+	@Override
+	protected void onDestroy() {
+		mapBase.onDestroy();
+	}
+
+	@Override
+	protected void onPause() {
+		mapBase.onPause();
+	}
+
+	@Override
+	protected void onResume() {
+		mapBase.onResume();
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		return mapBase.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		return mapBase.onOptionsItemSelected(item);
+	}
+
+	@Override
+	public boolean onPrepareOptionsMenu(Menu menu) {
+		return mapBase.onPrepareOptionsMenu(menu);
+	}
+
+	@Override
+	protected void onStop() {
+		mapBase.onStop();
+	}
+
+	@Override
+	public void superOnCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+	}
+
+	@Override
+	public boolean superOnCreateOptionsMenu(Menu menu) {
+		return superOnCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public void superOnDestroy() {
+		super.onDestroy();
+	}
+
+	@Override
+	public boolean superOnOptionsItemSelected(MenuItem item) {
+		return super.onOptionsItemSelected(item);
+	}
+
+	@Override
+	public void superOnResume() {
+		super.onResume();
+	}
+
+	@Override
+	public boolean superOnPrepareOptionsMenu(Menu menu) {
+		return super.onPrepareOptionsMenu(menu);
+	}
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfMapController.java b/src/cgeo/geocaching/mapsforge/mfMapController.java
new file mode 100644
index 0000000..30f1c29
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfMapController.java
@@ -0,0 +1,43 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+import org.mapsforge.android.maps.MapController;
+
+import cgeo.geocaching.mapinterfaces.GeoPointImpl;
+import cgeo.geocaching.mapinterfaces.MapControllerImpl;
+
+public class mfMapController implements MapControllerImpl {
+
+	private MapController mapController;
+	
+	public mfMapController(MapController mapControllerIn) {
+		mapController = mapControllerIn;
+	}
+
+	@Override
+	public void animateTo(GeoPointImpl geoPoint) {
+		mapController.setCenter((GeoPoint)geoPoint);
+	}
+
+	@Override
+	public void setCenter(GeoPointImpl geoPoint) {
+		mapController.setCenter((GeoPoint)geoPoint);
+	}
+
+	@Override
+	public void setZoom(int mapzoom) {
+		mapController.setZoom(mapzoom);
+	}
+
+	@Override
+	public void zoomToSpan(int latSpanE6, int lonSpanE6) {
+		
+		if (latSpanE6 != 0 && lonSpanE6 != 0) {
+			// calculate zoomlevel
+			int distDegree = Math.max(latSpanE6, lonSpanE6);
+			int zoomLevel = (int) Math.floor(Math.log(360.0*1e6/distDegree)/Math.log(2));
+			mapController.setZoom(zoomLevel);
+			}		
+	}	
+}
+
diff --git a/src/cgeo/geocaching/mapsforge/mfMapFactory.java b/src/cgeo/geocaching/mapsforge/mfMapFactory.java
new file mode 100644
index 0000000..2031187
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfMapFactory.java
@@ -0,0 +1,54 @@
+package cgeo.geocaching.mapsforge;
+
+import android.content.Context;
+import cgeo.geocaching.R;
+import cgeo.geocaching.cgCoord;
+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{
+
+	@Override
+	public Class getMapClass() {
+		return mfMapActivity.class;
+	}
+
+	@Override
+	public int getMapViewId() {
+		return R.id.mfmap;
+	}
+
+	@Override
+	public int getMapLayoutId() {
+		return R.layout.mfmap;
+	}
+
+	@Override
+	public GeoPointImpl getGeoPointBase(int latE6, int lonE6) {
+		return new mfGeoPoint(latE6, lonE6);
+	}
+
+	@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;
+	}
+
+	@Override
+	public UserOverlayItemImpl getUserOverlayItemBase(Context context, cgUser userOne) {
+		mfUsersOverlayItem baseItem = new mfUsersOverlayItem(context, userOne);
+		return baseItem;
+	}
+
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfMapProjection.java b/src/cgeo/geocaching/mapsforge/mfMapProjection.java
new file mode 100644
index 0000000..7252b17
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfMapProjection.java
@@ -0,0 +1,28 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+import org.mapsforge.android.maps.Projection;
+
+import cgeo.geocaching.mapinterfaces.GeoPointImpl;
+import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
+import android.graphics.Point;
+
+public class mfMapProjection implements MapProjectionImpl {
+
+	private Projection projection;
+
+	public mfMapProjection(Projection projectionIn) {
+		projection = projectionIn;
+	}
+
+	@Override
+	public void toPixels(GeoPointImpl leftGeo, Point left) {
+		projection.toPixels((GeoPoint) leftGeo, left);
+	}
+
+	@Override
+	public Object getImpl() {
+		return projection;
+	}
+
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfMapView.java b/src/cgeo/geocaching/mapsforge/mfMapView.java
new file mode 100644
index 0000000..a68e7c0
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfMapView.java
@@ -0,0 +1,159 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+import org.mapsforge.android.maps.MapView;
+import org.mapsforge.android.maps.MapViewMode;
+import org.mapsforge.android.maps.Overlay;
+import org.mapsforge.android.maps.Projection;
+
+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.cgMapOverlay;
+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.OverlayImpl;
+
+public class mfMapView extends MapView implements MapViewImpl {
+
+	public mfMapView(Context context, AttributeSet attrs) {
+		super(context, attrs);
+	}
+
+	@Override
+	public void draw(Canvas canvas) {
+		try {
+			if (getMapZoomLevel() >= 22) { // to avoid too close zoom level (mostly on Samsung Galaxy S series)
+				getController().setZoom(22);
+			}
+
+			super.draw(canvas);
+		} catch (Exception e) {
+			Log.e(cgSettings.tag, "cgMapView.draw: " + e.toString());
+		}
+	}
+
+	@Override
+	public void displayZoomControls(boolean takeFocus) {
+		// nothing to do here
+	}
+
+	@Override
+	public MapControllerImpl getMapController() {
+		return new mfMapController(getController());
+	}
+
+	@Override
+	public GeoPointImpl getMapViewCenter() {
+		GeoPoint point = getMapCenter();
+		return new mfGeoPoint(point.getLatitudeE6(), point.getLongitudeE6());
+	}
+
+	@Override
+	public void addOverlay(OverlayImpl ovl) {
+		getOverlays().add((Overlay)ovl);
+	}
+
+	@Override
+	public void clearOverlays() {
+		getOverlays().clear();
+	}
+
+	@Override
+	public MapProjectionImpl getMapProjection() {
+		return new mfMapProjection(getProjection());
+	}
+
+	@Override
+	public cgMapOverlay createAddMapOverlay(cgSettings settings,
+			Context context, Drawable drawable, boolean fromDetailIntent) {
+		
+		mfCacheOverlay ovl = new mfCacheOverlay(settings, context, drawable, fromDetailIntent);
+		getOverlays().add(ovl);
+		return ovl.getBase();
+	}
+	
+	@Override
+	public cgUsersOverlay createAddUsersOverlay(Context context, Drawable markerIn) {
+		mfUsersOverlay ovl = new mfUsersOverlay(context, markerIn);
+		getOverlays().add(ovl);
+		return ovl.getBase();
+	}
+
+	@Override
+	public int getLatitudeSpan() {
+
+		Projection projection = getProjection();
+		
+		GeoPoint low = projection.fromPixels(0, 0);
+		GeoPoint high = projection.fromPixels(0, getHeight());
+
+		return Math.abs(high.getLatitudeE6() - low.getLatitudeE6());
+	}
+
+	@Override
+	public int getLongitudeSpan() {
+		Projection projection = getProjection();
+		
+		GeoPoint low = projection.fromPixels(0, 0);
+		GeoPoint high = projection.fromPixels(getWidth(), 0);
+
+		return Math.abs(high.getLongitudeE6() - low.getLongitudeE6());
+	}
+
+	@Override
+	public boolean isSatellite() {
+		return false;
+	}
+
+	@Override
+	public void preLoad() {
+		// Nothing to do here
+	}
+
+	@Override
+	public void setSatellite(boolean b) {
+		// Nothing to do here
+	}
+
+	@Override
+	public int getMapZoomLevel() {
+		return getZoomLevel();
+	}
+
+	@Override
+	public boolean needsScaleOverlay() {
+		return false;
+	}
+
+	@Override
+	public void setBuiltinScale(boolean b) {
+		setScaleBar(b);
+	}
+
+	@Override
+	public void setMapSource(cgSettings settings) {
+
+		setMapViewMode(MapViewMode.MAPNIK_TILE_DOWNLOAD);
+		
+		switch(settings.mapProvider) {
+			case mapsforgeMapnik:
+				// is default
+				break;
+			case mapsforgeOsmarender:
+				setMapViewMode(MapViewMode.OSMARENDER_TILE_DOWNLOAD);
+				break;
+			case mapsforgeOffline:
+				if (isValidMapFile(settings.getMapFile())) {
+					setMapViewMode(MapViewMode.CANVAS_RENDERER);
+					super.setMapFile(settings.getMapFile());
+				}
+		}
+	}
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfOverlay.java b/src/cgeo/geocaching/mapsforge/mfOverlay.java
new file mode 100644
index 0000000..e015307
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfOverlay.java
@@ -0,0 +1,26 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.Overlay;
+import org.mapsforge.android.maps.Projection;
+
+import android.graphics.Canvas;
+import android.graphics.Point;
+import cgeo.geocaching.mapinterfaces.OverlayBase;
+import cgeo.geocaching.mapinterfaces.OverlayImpl;
+
+public class mfOverlay extends Overlay implements OverlayImpl {
+
+	private OverlayBase overlayBase;
+	
+	public mfOverlay(OverlayBase overlayBaseIn) {
+		overlayBase = overlayBaseIn;
+	}
+	
+	@Override
+	protected void drawOverlayBitmap(Canvas canvas, Point drawPosition,
+			Projection projection, byte drawZoomLevel) {
+		
+		overlayBase.drawOverlayBitmap(canvas, drawPosition, new mfMapProjection(projection), drawZoomLevel);
+	}
+
+}
diff --git a/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java b/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java
new file mode 100644
index 0000000..64ccc37
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfUsersOverlay.java
@@ -0,0 +1,98 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.ItemizedOverlay;
+import org.mapsforge.android.maps.MapView;
+import org.mapsforge.android.maps.Projection;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Point;
+import android.graphics.drawable.Drawable;
+import cgeo.geocaching.mapcommon.cgUsersOverlay;
+import cgeo.geocaching.mapinterfaces.ItemizedOverlayImpl;
+import cgeo.geocaching.mapinterfaces.MapProjectionImpl;
+import cgeo.geocaching.mapinterfaces.MapViewImpl;
+
+public class mfUsersOverlay extends ItemizedOverlay<mfUsersOverlayItem> implements ItemizedOverlayImpl {
+
+	private cgUsersOverlay base;
+
+	public mfUsersOverlay(Context contextIn, Drawable markerIn) {
+		super(boundCenter(markerIn));
+		base = new cgUsersOverlay(this, contextIn);
+	}
+	
+	@Override
+	public cgUsersOverlay getBase() {
+		return base;
+	}
+
+	@Override
+	protected mfUsersOverlayItem createItem(int i) {
+		if (base == null)
+			return null;
+
+		return (mfUsersOverlayItem) base.createItem(i);
+	}
+
+	@Override
+	public int size() {
+		if (base == null)
+			return 0;
+
+		return base.size();
+	}
+
+	@Override
+	protected boolean onTap(int arg0) {
+		if (base == null)
+			return false;
+		
+		return base.onTap(arg0);
+	}
+
+	@Override
+	protected void drawOverlayBitmap(Canvas canvas, Point drawPosition,
+			Projection projection, byte drawZoomLevel) {
+		
+		base.drawOverlayBitmap(canvas, drawPosition, new mfMapProjection(projection), drawZoomLevel);
+	}
+
+	@Override
+	public void superPopulate() {
+		populate();
+	}
+
+	@Override
+	public Drawable superBoundCenter(Drawable markerIn) {
+		return super.boundCenter(markerIn);
+	}
+
+	@Override
+	public Drawable superBoundCenterBottom(Drawable marker) {
+		return super.boundCenterBottom(marker);
+	}
+
+	@Override
+	public void superSetLastFocusedItemIndex(int i) {
+		// Nothing to do here
+	}
+
+	@Override
+	public boolean superOnTap(int index) {
+		return super.onTap(index);
+	}
+
+	@Override
+	public void superDraw(Canvas canvas, MapViewImpl mapView, boolean shadow) {
+		// Nothing to do here
+	}
+
+	@Override
+	public void superDrawOverlayBitmap(Canvas canvas, Point drawPosition,
+			MapProjectionImpl projection, byte drawZoomLevel) {
+		
+		super.drawOverlayBitmap(canvas, drawPosition, (Projection) projection.getImpl(), drawZoomLevel);
+	}
+
+}
\ No newline at end of file
diff --git a/src/cgeo/geocaching/mapsforge/mfUsersOverlayItem.java b/src/cgeo/geocaching/mapsforge/mfUsersOverlayItem.java
new file mode 100644
index 0000000..a38a0a6
--- /dev/null
+++ b/src/cgeo/geocaching/mapsforge/mfUsersOverlayItem.java
@@ -0,0 +1,43 @@
+package cgeo.geocaching.mapsforge;
+
+import org.mapsforge.android.maps.GeoPoint;
+import org.mapsforge.android.maps.OverlayItem;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import cgeo.geocaching.R;
+import cgeo.geocaching.cgUser;
+import cgeo.geocaching.mapinterfaces.UserOverlayItemImpl;
+
+public class mfUsersOverlayItem extends OverlayItem implements UserOverlayItemImpl {
+	private Context context = null;
+	private cgUser user = null;
+
+	public mfUsersOverlayItem(Context contextIn, cgUser userIn) {
+		super(new GeoPoint((int)(userIn.latitude * 1e6), (int)(userIn.longitude * 1e6)), userIn.username, "");
+
+		context = contextIn;
+		user = userIn;
+	}
+
+	@Override
+	public Drawable getMarker(int state) {
+		Drawable marker = null;
+		
+		if (user != null && user.located != null && user.located.getTime() >= (System.currentTimeMillis() - (20 * 60 * 1000))) {
+			marker = context.getResources().getDrawable(R.drawable.user_location_active);
+		} else {
+			marker = context.getResources().getDrawable(R.drawable.user_location);
+		}
+
+		marker.setBounds(0, 0, marker.getIntrinsicWidth(), marker.getIntrinsicHeight());
+		marker.setAlpha(190);
+		setMarker(marker);
+
+		return marker;
+	}
+
+	public cgUser getUser() {
+		return user;
+	}
+}