diff options
Diffstat (limited to 'main')
27 files changed, 1082 insertions, 74 deletions
diff --git a/main/.classpath b/main/.classpath index 8b36cb6..44706dc 100644 --- a/main/.classpath +++ b/main/.classpath @@ -8,6 +8,7 @@ <classpathentry kind="lib" path="libs/commons-collections-3.2.1.jar"/> <classpathentry kind="lib" path="libs/android-support-v4.jar"/> <classpathentry kind="lib" path="libs/mapsforge-map-0.3.0-jar-with-dependencies.jar"/> + <classpathentry kind="lib" path="libs/mapsforge-map-0.2.4.jar"/> <classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/> <classpathentry kind="output" path="bin/classes"/> </classpath> diff --git a/main/AndroidManifest.xml b/main/AndroidManifest.xml index 9be66db..686c5ee 100644 --- a/main/AndroidManifest.xml +++ b/main/AndroidManifest.xml @@ -138,6 +138,11 @@ android:configChanges="keyboardHidden|orientation" > </activity> <activity + android:name=".maps.mapsforge.v024.MapsforgeMapActivity024" + android:label="@string/app_name" + android:configChanges="keyboardHidden|orientation" > + </activity> + <activity android:name=".StaticMapsActivity" android:label="@string/app_name" android:configChanges="keyboardHidden|orientation" > diff --git a/main/libs/mapsforge-map-0.2.4.jar b/main/libs/mapsforge-map-0.2.4.jar Binary files differnew file mode 100644 index 0000000..ec9aa4c --- /dev/null +++ b/main/libs/mapsforge-map-0.2.4.jar diff --git a/main/res/layout/map_mapsforge_old.xml b/main/res/layout/map_mapsforge_old.xml new file mode 100644 index 0000000..00ee46d --- /dev/null +++ b/main/res/layout/map_mapsforge_old.xml @@ -0,0 +1,48 @@ +<?xml version="1.0" encoding="utf-8"?> +<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + android:layout_width="fill_parent" + android:layout_height="fill_parent" + android:orientation="vertical" + android:background="?background_color" > + <LinearLayout style="@style/action_bar"> + <ImageView style="@style/action_bar_action" + android:onClick="goHome" /> + <View style="@style/action_bar_separator" /> + <TextView style="@style/action_bar_title" /> + <ProgressBar style="@style/action_bar_progress" + android:visibility="gone" /> + <View style="@style/action_bar_separator" /> + <ImageSwitcher style="@style/action_bar_action" + android:id="@+id/my_position" /> + <View style="@style/action_bar_separator" /> + <ImageView style="@style/action_bar_action" + android:src="@drawable/actionbar_manual" + android:onClick="goManual" /> + </LinearLayout> + <include layout="@layout/filter_bar"/> + <RelativeLayout + android:layout_width="fill_parent" + android:layout_height="fill_parent" > + <TextView android:id="@+id/number" + android:visibility="gone" + android:layout_width="wrap_content" + android:layout_height="wrap_content" + android:layout_margin="5dip" + android:gravity="center_horizontal" + android:paddingLeft="5dip" + android:paddingRight="5dip" + android:lines="1" + android:singleLine="true" + android:scrollHorizontally="true" + android:ellipsize="marquee" + android:textSize="12dip" + android:textColor="@color/text_icon" + android:background="@drawable/icon_bcg" /> + <view class="cgeo.geocaching.maps.mapsforge.v024.MapsforgeMapView024" android:id="@+id/mfmap_old" + android:layout_width="fill_parent" + android:layout_height="fill_parent" + android:keepScreenOn="true" + android:enabled="true" + android:clickable="true" /> + </RelativeLayout> +</LinearLayout>
\ No newline at end of file diff --git a/main/res/values/strings.xml b/main/res/values/strings.xml index 625e90a..98f7c90 100644 --- a/main/res/values/strings.xml +++ b/main/res/values/strings.xml @@ -219,6 +219,7 @@ <string name="warn_log_text_fill">Please fill in text for your log.</string> <string name="warn_load_images">c:geo failed to load images.</string> <string name="warn_invalid_mapfile">The selected map file is not a valid mapsforge version 0.3.0 map file.\nOffline maps are not available.</string> + <string name="warn_deprecated_mapfile">You are using a deprecated version 0.2.4 map file.\nConsider switching to a version 0.3.0 map.\nWe will drop support for version 0.2.4 in the next release.</string> <string name="info_log_posted">c:geo successfully submitted the log.</string> <string name="info_log_saved">c:geo successfully saved the log.</string> diff --git a/main/src/cgeo/geocaching/Settings.java b/main/src/cgeo/geocaching/Settings.java index 08a9415..e46516f 100644 --- a/main/src/cgeo/geocaching/Settings.java +++ b/main/src/cgeo/geocaching/Settings.java @@ -808,7 +808,7 @@ public final class Settings { } public static void setMapSource(final int newMapSource) { - if (!MapProviderFactory.isSameProvider(getMapSource(), newMapSource)) { + if (!MapProviderFactory.isSameActivity(getMapSource(), newMapSource)) { mapProvider = null; } editSharedSettings(new PrefRunnable() { diff --git a/main/src/cgeo/geocaching/maps/CGeoMap.java b/main/src/cgeo/geocaching/maps/CGeoMap.java index 1b6be1e..3e4cca3 100644 --- a/main/src/cgeo/geocaching/maps/CGeoMap.java +++ b/main/src/cgeo/geocaching/maps/CGeoMap.java @@ -9,11 +9,11 @@ import cgeo.geocaching.R; import cgeo.geocaching.SearchResult; import cgeo.geocaching.Settings; import cgeo.geocaching.StoredList; -import cgeo.geocaching.activity.ActivityMixin; import cgeo.geocaching.cgCache; import cgeo.geocaching.cgWaypoint; import cgeo.geocaching.cgeoapplication; import cgeo.geocaching.cgeocaches; +import cgeo.geocaching.activity.ActivityMixin; import cgeo.geocaching.connector.ConnectorFactory; import cgeo.geocaching.connector.gc.GCBase; import cgeo.geocaching.connector.gc.Login; @@ -30,6 +30,7 @@ import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; import cgeo.geocaching.maps.interfaces.GeoPointImpl; import cgeo.geocaching.maps.interfaces.MapActivityImpl; import cgeo.geocaching.maps.interfaces.MapControllerImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; import cgeo.geocaching.maps.interfaces.MapProvider; import cgeo.geocaching.maps.interfaces.MapViewImpl; import cgeo.geocaching.maps.interfaces.OnMapDragListener; @@ -117,6 +118,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto private Resources res = null; private MapProvider mapProvider = null; + private MapItemFactory mapItemFactory = null; private Activity activity = null; private MapViewImpl mapView = null; private MapControllerImpl mapController = null; @@ -355,6 +357,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto activity = this.getActivity(); app = (cgeoapplication) activity.getApplication(); mapProvider = Settings.getMapProvider(); + mapItemFactory = mapProvider.getMapItemFactory(); // Get parameters from the intent @@ -738,7 +741,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto * @return true if a restart is needed, false otherwise */ private boolean changeMapSource(final int mapSource) { - final boolean restartRequired = !MapProviderFactory.isSameProvider(currentSourceId, mapSource); + final boolean restartRequired = !MapProviderFactory.isSameActivity(currentSourceId, mapSource); Settings.setMapSource(mapSource); currentSourceId = mapSource; @@ -1270,7 +1273,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto continue; } - item = mapProvider.getOtherCachersOverlayItemBase(activity, userOne); + item = mapItemFactory.getOtherCachersOverlayItemBase(activity, userOne); items.add(item); counter++; @@ -1441,7 +1444,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto if (!centered && mapState != null) { try { - mapController.setCenter(mapProvider.getGeoPointBase(new Geopoint(mapState[0] / 1.0e6, mapState[1] / 1.0e6))); + mapController.setCenter(mapItemFactory.getGeoPointBase(new Geopoint(mapState[0] / 1.0e6, mapState[1] / 1.0e6))); mapController.setZoom(mapState[2]); } catch (Exception e) { // nothing at all @@ -1463,7 +1466,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto return; } - mapController.setCenter(mapProvider.getGeoPointBase(viewport.center)); + mapController.setCenter(mapItemFactory.getGeoPointBase(viewport.center)); if (viewport.getLatitudeSpan() != 0 && viewport.getLongitudeSpan() != 0) { mapController.zoomToSpan((int) (viewport.getLatitudeSpan() * 1e6), (int) (viewport.getLongitudeSpan() * 1e6)); } @@ -1513,7 +1516,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto // make geopoint private GeoPointImpl makeGeoPoint(final Geopoint coords) { - return mapProvider.getGeoPointBase(coords); + return mapItemFactory.getGeoPointBase(coords); } // close activity and open homescreen @@ -1592,7 +1595,9 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto */ private CachesOverlayItemImpl getItem(final IWaypoint coord, final cgCache cache, final cgWaypoint waypoint) { if (cache != null) { - final CachesOverlayItemImpl item = mapProvider.getCachesOverlayItem(coord, cache.getType()); + final CachesOverlayItemImpl item = mapItemFactory.getCachesOverlayItem(coord, cache.getType()); + + final int hashcode = new HashCodeBuilder() .append(cache.isReliableLatLon()) .append(cache.getType().id) @@ -1670,7 +1675,8 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto } if (waypoint != null) { - final CachesOverlayItemImpl item = mapProvider.getCachesOverlayItem(coord, null); + + final CachesOverlayItemImpl item = mapItemFactory.getCachesOverlayItem(coord, null); Drawable[] layers = new Drawable[2]; layers[0] = getResources().getDrawable(R.drawable.marker); layers[1] = getResources().getDrawable(waypoint.getWaypointType().markerId); diff --git a/main/src/cgeo/geocaching/maps/CachesOverlay.java b/main/src/cgeo/geocaching/maps/CachesOverlay.java index d3a7865..923c5e4 100644 --- a/main/src/cgeo/geocaching/maps/CachesOverlay.java +++ b/main/src/cgeo/geocaching/maps/CachesOverlay.java @@ -9,6 +9,7 @@ import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; import cgeo.geocaching.maps.interfaces.GeoPointImpl; import cgeo.geocaching.maps.interfaces.ItemizedOverlayImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; import cgeo.geocaching.maps.interfaces.MapProjectionImpl; import cgeo.geocaching.maps.interfaces.MapProvider; import cgeo.geocaching.maps.interfaces.MapViewImpl; @@ -39,6 +40,7 @@ public class CachesOverlay extends AbstractItemizedOverlay { private PaintFlagsDrawFilter setFilter = null; private PaintFlagsDrawFilter removeFilter = null; private MapProvider mapProvider = null; + private MapItemFactory mapItemFactory = null; public CachesOverlay(ItemizedOverlayImpl ovlImpl, Context contextIn) { super(ovlImpl); @@ -48,6 +50,7 @@ public class CachesOverlay extends AbstractItemizedOverlay { context = contextIn; mapProvider = Settings.getMapProvider(); + mapItemFactory = mapProvider.getMapItemFactory(); } public void updateItems(CachesOverlayItemImpl item) { @@ -119,7 +122,7 @@ public class CachesOverlay extends AbstractItemizedOverlay { for (CachesOverlayItemImpl item : items) { final Geopoint itemCoord = item.getCoord().getCoords(); - final GeoPointImpl itemGeo = mapProvider.getGeoPointBase(itemCoord); + final GeoPointImpl itemGeo = mapItemFactory.getGeoPointBase(itemCoord); projection.toPixels(itemGeo, center); final CacheType type = item.getType(); @@ -159,11 +162,11 @@ public class CachesOverlay extends AbstractItemizedOverlay { itemCoord.getLatitude(), itemCoord.getLongitude() + 1, distanceArray); final float longitudeLineDistance = distanceArray[0]; - final GeoPointImpl itemGeo = mapProvider.getGeoPointBase(itemCoord); + final GeoPointImpl itemGeo = mapItemFactory.getGeoPointBase(itemCoord); final Geopoint leftCoords = new Geopoint(itemCoord.getLatitude(), itemCoord.getLongitude() - 161 / longitudeLineDistance); - final GeoPointImpl leftGeo = mapProvider.getGeoPointBase(leftCoords); + final GeoPointImpl leftGeo = mapItemFactory.getGeoPointBase(leftCoords); final Point center = new Point(); projection.toPixels(itemGeo, center); diff --git a/main/src/cgeo/geocaching/maps/MapProviderFactory.java b/main/src/cgeo/geocaching/maps/MapProviderFactory.java index 3509209..10ca12a 100644 --- a/main/src/cgeo/geocaching/maps/MapProviderFactory.java +++ b/main/src/cgeo/geocaching/maps/MapProviderFactory.java @@ -61,10 +61,10 @@ public class MapProviderFactory { return getInstance().mapSources.containsKey(sourceId); } - public static boolean isSameProvider(int sourceId1, int sourceId2) { + public static boolean isSameActivity(int sourceId1, int sourceId2) { for (MapProvider mp : getInstance().mapProviders) { if (mp.isMySource(sourceId1) && mp.isMySource(sourceId2)) { - return true; + return mp.isSameActivity(sourceId1, sourceId2); } } return false; diff --git a/main/src/cgeo/geocaching/maps/PositionOverlay.java b/main/src/cgeo/geocaching/maps/PositionOverlay.java index 9099498..5c88f08 100644 --- a/main/src/cgeo/geocaching/maps/PositionOverlay.java +++ b/main/src/cgeo/geocaching/maps/PositionOverlay.java @@ -5,6 +5,7 @@ import cgeo.geocaching.Settings; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.maps.interfaces.GeneralOverlay; import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; import cgeo.geocaching.maps.interfaces.MapProjectionImpl; import cgeo.geocaching.maps.interfaces.MapProvider; import cgeo.geocaching.maps.interfaces.MapViewImpl; @@ -44,17 +45,19 @@ public class PositionOverlay implements GeneralOverlay { private Point historyPointP = new Point(); private Activity activity; private MapProvider mapProvider = null; + private MapItemFactory mapItemFactory = null; private OverlayImpl ovlImpl = null; public PositionOverlay(Activity activity, OverlayImpl ovlImpl) { this.activity = activity; this.mapProvider = Settings.getMapProvider(); + this.mapItemFactory = this.mapProvider.getMapItemFactory(); this.ovlImpl = ovlImpl; } public void setCoordinates(Location coordinatesIn) { coordinates = coordinatesIn; - location = mapProvider.getGeoPointBase(new Geopoint(coordinates)); + location = mapItemFactory.getGeoPointBase(new Geopoint(coordinates)); } public void setHeading(Float bearingNow) { @@ -119,7 +122,7 @@ public class PositionOverlay implements GeneralOverlay { float longitudeLineDistance = result[0]; final Geopoint leftCoords = new Geopoint(latitude, longitude - accuracy / longitudeLineDistance); - GeoPointImpl leftGeo = mapProvider.getGeoPointBase(leftCoords); + GeoPointImpl leftGeo = mapItemFactory.getGeoPointBase(leftCoords); projection.toPixels(leftGeo, left); projection.toPixels(location, center); int radius = center.x - left.x; @@ -161,8 +164,8 @@ public class PositionOverlay implements GeneralOverlay { Location now = history.get(cnt); if (prev != null && now != null) { - projection.toPixels(mapProvider.getGeoPointBase(new Geopoint(prev)), historyPointP); - projection.toPixels(mapProvider.getGeoPointBase(new Geopoint(now)), historyPointN); + projection.toPixels(mapItemFactory.getGeoPointBase(new Geopoint(prev)), historyPointP); + projection.toPixels(mapItemFactory.getGeoPointBase(new Geopoint(now)), historyPointN); if ((alphaCnt - cnt) > 0) { alpha = 255 / (alphaCnt - cnt); @@ -185,8 +188,8 @@ public class PositionOverlay implements GeneralOverlay { Location now = coordinates; if (prev != null && now != null) { - projection.toPixels(mapProvider.getGeoPointBase(new Geopoint(prev)), historyPointP); - projection.toPixels(mapProvider.getGeoPointBase(new Geopoint(now)), historyPointN); + projection.toPixels(mapItemFactory.getGeoPointBase(new Geopoint(prev)), historyPointP); + projection.toPixels(mapItemFactory.getGeoPointBase(new Geopoint(now)), historyPointN); historyLineShadow.setAlpha(255); historyLine.setAlpha(255); @@ -224,4 +227,4 @@ public class PositionOverlay implements GeneralOverlay { public OverlayImpl getOverlayImpl() { return this.ovlImpl; } -}
\ No newline at end of file +} diff --git a/main/src/cgeo/geocaching/maps/google/GoogleMapItemFactory.java b/main/src/cgeo/geocaching/maps/google/GoogleMapItemFactory.java new file mode 100644 index 0000000..0e18dce --- /dev/null +++ b/main/src/cgeo/geocaching/maps/google/GoogleMapItemFactory.java @@ -0,0 +1,32 @@ +package cgeo.geocaching.maps.google; + +import cgeo.geocaching.IWaypoint; +import cgeo.geocaching.enumerations.CacheType; +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.go4cache.Go4CacheUser; +import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; +import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; + +import android.content.Context; + +public class GoogleMapItemFactory implements MapItemFactory { + + @Override + public GeoPointImpl getGeoPointBase(final Geopoint coords) { + return new GoogleGeoPoint(coords.getLatitudeE6(), coords.getLongitudeE6()); + } + + @Override + public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint coordinate, final CacheType type) { + GoogleCacheOverlayItem baseItem = new GoogleCacheOverlayItem(coordinate, type); + return baseItem; + } + + @Override + public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, Go4CacheUser userOne) { + GoogleOtherCachersOverlayItem baseItem = new GoogleOtherCachersOverlayItem(context, userOne); + return baseItem; + } +} diff --git a/main/src/cgeo/geocaching/maps/google/GoogleMapProvider.java b/main/src/cgeo/geocaching/maps/google/GoogleMapProvider.java index b659042..1cccbe3 100644 --- a/main/src/cgeo/geocaching/maps/google/GoogleMapProvider.java +++ b/main/src/cgeo/geocaching/maps/google/GoogleMapProvider.java @@ -1,20 +1,13 @@ package cgeo.geocaching.maps.google; -import cgeo.geocaching.IWaypoint; import cgeo.geocaching.R; import cgeo.geocaching.cgeoapplication; -import cgeo.geocaching.enumerations.CacheType; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.go4cache.Go4CacheUser; import cgeo.geocaching.maps.MapProviderFactory; -import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; -import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; import cgeo.geocaching.maps.interfaces.MapProvider; -import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; import com.google.android.maps.MapActivity; -import android.content.Context; import android.content.res.Resources; import java.util.HashMap; @@ -28,6 +21,7 @@ public class GoogleMapProvider implements MapProvider { private final Map<Integer, String> mapSources; private int baseId; + private final MapItemFactory mapItemFactory; public GoogleMapProvider(int _baseId) { baseId = _baseId; @@ -36,6 +30,8 @@ public class GoogleMapProvider implements MapProvider { mapSources = new HashMap<Integer, String>(); mapSources.put(baseId + MAP, resources.getString(R.string.map_source_google_map)); mapSources.put(baseId + SATELLITE, resources.getString(R.string.map_source_google_satellite)); + + mapItemFactory = new GoogleMapItemFactory(); } @Override @@ -76,18 +72,12 @@ public class GoogleMapProvider implements MapProvider { } @Override - public GeoPointImpl getGeoPointBase(final Geopoint coords) { - return new GoogleGeoPoint(coords.getLatitudeE6(), coords.getLongitudeE6()); + public MapItemFactory getMapItemFactory() { + return mapItemFactory; } @Override - public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint coordinate, final CacheType type) { - return new GoogleCacheOverlayItem(coordinate, type); + public boolean isSameActivity(int sourceId1, int sourceId2) { + return true; } - - @Override - public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, Go4CacheUser userOne) { - return new GoogleOtherCachersOverlayItem(context, userOne); - } - } diff --git a/main/src/cgeo/geocaching/maps/interfaces/MapItemFactory.java b/main/src/cgeo/geocaching/maps/interfaces/MapItemFactory.java new file mode 100644 index 0000000..c38739d --- /dev/null +++ b/main/src/cgeo/geocaching/maps/interfaces/MapItemFactory.java @@ -0,0 +1,18 @@ +package cgeo.geocaching.maps.interfaces; + +import cgeo.geocaching.IWaypoint; +import cgeo.geocaching.enumerations.CacheType; +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.go4cache.Go4CacheUser; + +import android.content.Context; + +public interface MapItemFactory { + + public GeoPointImpl getGeoPointBase(final Geopoint coords); + + public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint iWaypoint, final CacheType type); + + public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, + Go4CacheUser userOne); +} diff --git a/main/src/cgeo/geocaching/maps/interfaces/MapProvider.java b/main/src/cgeo/geocaching/maps/interfaces/MapProvider.java index dd935c4..626a410 100644 --- a/main/src/cgeo/geocaching/maps/interfaces/MapProvider.java +++ b/main/src/cgeo/geocaching/maps/interfaces/MapProvider.java @@ -1,12 +1,6 @@ package cgeo.geocaching.maps.interfaces; -import cgeo.geocaching.IWaypoint; -import cgeo.geocaching.enumerations.CacheType; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.go4cache.Go4CacheUser; - import android.app.Activity; -import android.content.Context; import java.util.Map; @@ -23,17 +17,13 @@ public interface MapProvider { public boolean isMySource(int sourceId); + public boolean isSameActivity(int sourceId1, int sourceId2); + public Class<? extends Activity> getMapClass(); public int getMapViewId(); public int getMapLayoutId(); - public GeoPointImpl getGeoPointBase(final Geopoint coords); - - public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint iWaypoint, final CacheType type); - - public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, - Go4CacheUser userOne); - + public MapItemFactory getMapItemFactory(); } diff --git a/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapItemFactory.java b/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapItemFactory.java new file mode 100644 index 0000000..5e86f81 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapItemFactory.java @@ -0,0 +1,33 @@ +package cgeo.geocaching.maps.mapsforge; + +import cgeo.geocaching.IWaypoint; +import cgeo.geocaching.enumerations.CacheType; +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.go4cache.Go4CacheUser; +import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; +import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; + +import android.content.Context; + +public class MapsforgeMapItemFactory implements MapItemFactory { + + @Override + public GeoPointImpl getGeoPointBase(final Geopoint coords) { + return new MapsforgeGeoPoint(coords.getLatitudeE6(), coords.getLongitudeE6()); + } + + @Override + public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint coordinate, final CacheType type) { + MapsforgeCacheOverlayItem baseItem = new MapsforgeCacheOverlayItem(coordinate, type); + return baseItem; + } + + @Override + public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, Go4CacheUser userOne) { + MapsforgeOtherCachersOverlayItem baseItem = new MapsforgeOtherCachersOverlayItem(context, userOne); + return baseItem; + } + +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapProvider.java b/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapProvider.java index f9882e0..026dd50 100644 --- a/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapProvider.java +++ b/main/src/cgeo/geocaching/maps/mapsforge/MapsforgeMapProvider.java @@ -1,23 +1,19 @@ package cgeo.geocaching.maps.mapsforge; -import cgeo.geocaching.IWaypoint; import cgeo.geocaching.R; +import cgeo.geocaching.Settings; import cgeo.geocaching.cgeoapplication; -import cgeo.geocaching.enumerations.CacheType; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.go4cache.Go4CacheUser; import cgeo.geocaching.maps.MapProviderFactory; -import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; -import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; import cgeo.geocaching.maps.interfaces.MapProvider; -import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; +import cgeo.geocaching.maps.mapsforge.v024.MapsforgeMapActivity024; +import cgeo.geocaching.maps.mapsforge.v024.MapsforgeMapItemFactory024; import org.apache.commons.lang3.StringUtils; import org.mapsforge.map.reader.MapDatabase; import org.mapsforge.map.reader.header.FileOpenResult; import android.app.Activity; -import android.content.Context; import android.content.res.Resources; import java.io.File; @@ -33,6 +29,8 @@ public class MapsforgeMapProvider implements MapProvider { private final Map<Integer, String> mapSources; private final int baseId; + private boolean oldMap = false; + private MapItemFactory mapItemFactory = new MapsforgeMapItemFactory(); public MapsforgeMapProvider(int _baseId) { baseId = _baseId; @@ -74,36 +72,59 @@ public class MapsforgeMapProvider implements MapProvider { FileOpenResult result = mapDB.openFile(new File(mapFileIn)); mapDB.closeFile(); - return result.isSuccess(); + boolean isValid = result.isSuccess(); + + if (!isValid) { + isValid = isMapfile024(mapFileIn); + } + + return isValid; + } + + private static boolean isMapfile024(String mapFileIn) { + return org.mapsforge.android.mapsold.MapDatabase.isValidMapFile(mapFileIn); + } + + @Override + public boolean isSameActivity(int sourceId1, int sourceId2) { + final int mfSourceId1 = getMapsforgeSource(sourceId1); + final int mfSourceId2 = getMapsforgeSource(sourceId2); + return mfSourceId1 == mfSourceId2 || + !isMapfile024(Settings.getMapFile()) || + mfSourceId1 != OFFLINE && mfSourceId2 != OFFLINE; } @Override public Class<? extends Activity> getMapClass() { + int sourceId = getMapsforgeSource(Settings.getMapSource()); + + if (sourceId == OFFLINE && isMapfile024(Settings.getMapFile())) { + oldMap = true; + mapItemFactory = new MapsforgeMapItemFactory024(); + return MapsforgeMapActivity024.class; + } + oldMap = false; + mapItemFactory = new MapsforgeMapItemFactory(); return MapsforgeMapActivity.class; } @Override public int getMapViewId() { + if (oldMap) { + return R.id.mfmap_old; + } return R.id.mfmap; } @Override public int getMapLayoutId() { + if (oldMap) { + return R.layout.map_mapsforge_old; + } return R.layout.map_mapsforge; } - - @Override - public GeoPointImpl getGeoPointBase(final Geopoint coords) { - return new MapsforgeGeoPoint(coords.getLatitudeE6(), coords.getLongitudeE6()); - } - - @Override - public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint coordinate, final CacheType type) { - return new MapsforgeCacheOverlayItem(coordinate, type); - } - @Override - public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, Go4CacheUser userOne) { - return new MapsforgeOtherCachersOverlayItem(context, userOne); + public MapItemFactory getMapItemFactory() { + return mapItemFactory; } } diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlay.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlay.java new file mode 100644 index 0000000..581548f --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlay.java @@ -0,0 +1,118 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.CachesOverlay; +import cgeo.geocaching.maps.interfaces.ItemizedOverlayImpl; +import cgeo.geocaching.maps.interfaces.MapProjectionImpl; +import cgeo.geocaching.maps.interfaces.MapViewImpl; + +import org.mapsforge.android.mapsold.ItemizedOverlay; +import org.mapsforge.android.mapsold.Projection; + +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Point; +import android.graphics.drawable.Drawable; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class MapsforgeCacheOverlay extends ItemizedOverlay<MapsforgeCacheOverlayItem> implements ItemizedOverlayImpl { + + private CachesOverlay base; + private Lock lock = new ReentrantLock(); + + public MapsforgeCacheOverlay(Context contextIn, Drawable markerIn) { + super(boundCenterBottom(markerIn)); + base = new CachesOverlay(this, contextIn); + } + + @Override + public CachesOverlay getBase() { + return base; + } + + @Override + protected MapsforgeCacheOverlayItem createItem(int i) { + if (base == null) { + return null; + } + + return (MapsforgeCacheOverlayItem) 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 MapsforgeMapProjection(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); + } + + @Override + public void lock() { + lock.lock(); + } + + @Override + public void unlock() { + lock.unlock(); + } + + @Override + public MapViewImpl getMapViewImpl() { + return (MapViewImpl) internalMapView; + } + +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlayItem.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlayItem.java new file mode 100644 index 0000000..3052e65 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeCacheOverlayItem.java @@ -0,0 +1,36 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.IWaypoint; +import cgeo.geocaching.enumerations.CacheType; +import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; + +import org.mapsforge.android.mapsold.GeoPoint; +import org.mapsforge.android.mapsold.OverlayItem; + +import android.graphics.drawable.Drawable; + +public class MapsforgeCacheOverlayItem extends OverlayItem implements CachesOverlayItemImpl { + final private CacheType cacheType; + final private IWaypoint coord; + + public MapsforgeCacheOverlayItem(IWaypoint coordinate, final CacheType type) { + super(new GeoPoint(coordinate.getCoords().getLatitudeE6(), coordinate.getCoords().getLongitudeE6()), coordinate.getName(), ""); + + this.cacheType = type; + this.coord = coordinate; + } + + public IWaypoint getCoord() { + return coord; + } + + public CacheType getType() { + return cacheType; + } + + @Override + public Drawable getMarker(int index) { + return getMarker(); + } + +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeGeoPoint.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeGeoPoint.java new file mode 100644 index 0000000..c801e3f --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeGeoPoint.java @@ -0,0 +1,18 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.maps.interfaces.GeoPointImpl; + +import org.mapsforge.android.mapsold.GeoPoint; + +public class MapsforgeGeoPoint extends GeoPoint implements GeoPointImpl { + + public MapsforgeGeoPoint(int latitudeE6, int longitudeE6) { + super(latitudeE6, longitudeE6); + } + + @Override + public Geopoint getCoords() { + return new Geopoint(getLatitudeE6() / 1e6, getLongitudeE6() / 1e6); + } +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapActivity024.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapActivity024.java new file mode 100644 index 0000000..52cfbb9 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapActivity024.java @@ -0,0 +1,122 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.AbstractMap; +import cgeo.geocaching.maps.CGeoMap; +import cgeo.geocaching.maps.interfaces.MapActivityImpl; + +import org.mapsforge.android.mapsold.MapActivity; + +import android.app.Activity; +import android.os.Bundle; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; + +public class MapsforgeMapActivity024 extends MapActivity implements MapActivityImpl { + + private AbstractMap mapBase; + + public MapsforgeMapActivity024() { + mapBase = new CGeoMap(this); + } + + @Override + public Activity getActivity() { + return this; + } + + @Override + protected void onCreate(Bundle icicle) { + mapBase.onCreate(icicle); + } + + @Override + protected void onSaveInstanceState(final Bundle outState) { + mapBase.onSaveInstanceState(outState); + } + + @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 super.onCreateOptionsMenu(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 void superOnStop() { + super.onStop(); + } + + @Override + public void superOnPause() { + super.onPause(); + } + + @Override + public boolean superOnPrepareOptionsMenu(Menu menu) { + return super.onPrepareOptionsMenu(menu); + } + + // close activity and open homescreen + public void goHome(View view) { + mapBase.goHome(view); + } + + // open manual entry + public void goManual(View view) { + mapBase.goManual(view); + } +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapController.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapController.java new file mode 100644 index 0000000..2160d21 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapController.java @@ -0,0 +1,48 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapControllerImpl; + +import org.mapsforge.android.mapsold.GeoPoint; +import org.mapsforge.android.mapsold.MapController; + +public class MapsforgeMapController implements MapControllerImpl { + + private MapController mapController; + private int maxZoomLevel; + + public MapsforgeMapController(MapController mapControllerIn, int maxZoomLevelIn) { + mapController = mapControllerIn; + maxZoomLevel = maxZoomLevelIn; + } + + @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) { + int mfzoom = mapzoom - 1; + if (mfzoom > maxZoomLevel) { + mfzoom = maxZoomLevel; + } + mapController.setZoom(mfzoom); + } + + @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 + 1); + } + } +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapItemFactory024.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapItemFactory024.java new file mode 100644 index 0000000..27cadd8 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapItemFactory024.java @@ -0,0 +1,33 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.IWaypoint; +import cgeo.geocaching.enumerations.CacheType; +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.go4cache.Go4CacheUser; +import cgeo.geocaching.maps.interfaces.CachesOverlayItemImpl; +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapItemFactory; +import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; + +import android.content.Context; + +public class MapsforgeMapItemFactory024 implements MapItemFactory { + + @Override + public GeoPointImpl getGeoPointBase(final Geopoint coords) { + return new MapsforgeGeoPoint(coords.getLatitudeE6(), coords.getLongitudeE6()); + } + + @Override + public CachesOverlayItemImpl getCachesOverlayItem(final IWaypoint coordinate, final CacheType type) { + MapsforgeCacheOverlayItem baseItem = new MapsforgeCacheOverlayItem(coordinate, type); + return baseItem; + } + + @Override + public OtherCachersOverlayItemImpl getOtherCachersOverlayItemBase(Context context, Go4CacheUser userOne) { + MapsforgeOtherCachersOverlayItem baseItem = new MapsforgeOtherCachersOverlayItem(context, userOne); + return baseItem; + } + +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapProjection.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapProjection.java new file mode 100644 index 0000000..9d36b7d --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapProjection.java @@ -0,0 +1,29 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapProjectionImpl; + +import org.mapsforge.android.mapsold.GeoPoint; +import org.mapsforge.android.mapsold.Projection; + +import android.graphics.Point; + +public class MapsforgeMapProjection implements MapProjectionImpl { + + private Projection projection; + + public MapsforgeMapProjection(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/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapView024.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapView024.java new file mode 100644 index 0000000..5963d32 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeMapView024.java @@ -0,0 +1,239 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.R; +import cgeo.geocaching.Settings; +import cgeo.geocaching.geopoint.Viewport; +import cgeo.geocaching.maps.CachesOverlay; +import cgeo.geocaching.maps.OtherCachersOverlay; +import cgeo.geocaching.maps.PositionOverlay; +import cgeo.geocaching.maps.ScaleOverlay; +import cgeo.geocaching.maps.interfaces.GeneralOverlay; +import cgeo.geocaching.maps.interfaces.GeoPointImpl; +import cgeo.geocaching.maps.interfaces.MapControllerImpl; +import cgeo.geocaching.maps.interfaces.MapProjectionImpl; +import cgeo.geocaching.maps.interfaces.MapViewImpl; +import cgeo.geocaching.maps.interfaces.OnMapDragListener; +import cgeo.geocaching.maps.interfaces.OverlayImpl; +import cgeo.geocaching.maps.interfaces.OverlayImpl.overlayType; +import cgeo.geocaching.utils.Log; + +import org.mapsforge.android.mapsold.GeoPoint; +import org.mapsforge.android.mapsold.MapDatabase; +import org.mapsforge.android.mapsold.MapView; +import org.mapsforge.android.mapsold.MapViewMode; +import org.mapsforge.android.mapsold.Overlay; +import org.mapsforge.android.mapsold.Projection; + +import android.app.Activity; +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.drawable.Drawable; +import android.util.AttributeSet; +import android.view.GestureDetector; +import android.view.GestureDetector.SimpleOnGestureListener; +import android.view.MotionEvent; +import android.widget.Toast; +public class MapsforgeMapView024 extends MapView implements MapViewImpl { + private GestureDetector gestureDetector; + private OnMapDragListener onDragListener; + + public MapsforgeMapView024(Context context, AttributeSet attrs) { + super(context, attrs); + gestureDetector = new GestureDetector(context, new GestureListener()); + } + + @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("MapsforgeMapView.draw: " + e.toString()); + } + } + + @Override + public void displayZoomControls(boolean takeFocus) { + // nothing to do here + } + + @Override + public MapControllerImpl getMapController() { + return new MapsforgeMapController(getController(), getMaxZoomLevel()); + } + + @Override + public GeoPointImpl getMapViewCenter() { + GeoPoint point = getMapCenter(); + return new MapsforgeGeoPoint(point.getLatitudeE6(), point.getLongitudeE6()); + } + + @Override + public Viewport getViewport() { + return new Viewport(getMapViewCenter(), getLatitudeSpan() / 1e6, getLongitudeSpan() / 1e6); + } + + @Override + public void addOverlay(OverlayImpl ovl) { + getOverlays().add((Overlay) ovl); + } + + @Override + public void clearOverlays() { + getOverlays().clear(); + } + + @Override + public MapProjectionImpl getMapProjection() { + return new MapsforgeMapProjection(getProjection()); + } + + @Override + public CachesOverlay createAddMapOverlay(Context context, Drawable drawable) { + + MapsforgeCacheOverlay ovl = new MapsforgeCacheOverlay(context, drawable); + getOverlays().add(ovl); + return ovl.getBase(); + } + + @Override + public OtherCachersOverlay createAddUsersOverlay(Context context, Drawable markerIn) { + MapsforgeOtherCachersOverlay ovl = new MapsforgeOtherCachersOverlay(context, markerIn); + getOverlays().add(ovl); + return ovl.getBase(); + } + + @Override + public PositionOverlay createAddPositionOverlay(Activity activity) { + MapsforgeOverlay ovl = new MapsforgeOverlay(activity, overlayType.PositionOverlay); + getOverlays().add(ovl); + return (PositionOverlay) ovl.getBase(); + } + + @Override + public ScaleOverlay createAddScaleOverlay(Activity activity) { + MapsforgeOverlay ovl = new MapsforgeOverlay(activity, overlayType.ScaleOverlay); + getOverlays().add(ovl); + return (ScaleOverlay) ovl.getBase(); + } + + @Override + public int getLatitudeSpan() { + + int span = 0; + + Projection projection = getProjection(); + + if (projection != null && getHeight() > 0) { + + GeoPoint low = projection.fromPixels(0, 0); + GeoPoint high = projection.fromPixels(0, getHeight()); + + if (low != null && high != null) { + span = Math.abs(high.getLatitudeE6() - low.getLatitudeE6()); + } + } + + return span; + } + + @Override + public int getLongitudeSpan() { + + int span = 0; + + Projection projection = getProjection(); + + if (projection != null && getWidth() > 0) { + GeoPoint low = projection.fromPixels(0, 0); + GeoPoint high = projection.fromPixels(getWidth(), 0); + + if (low != null && high != null) { + span = Math.abs(high.getLongitudeE6() - low.getLongitudeE6()); + } + } + + return span; + } + + @Override + public void preLoad() { + // Nothing to do here + } + + @Override + public int getMapZoomLevel() { + return getZoomLevel() + 1; + } + + @Override + public void setMapSource() { + setMapViewMode(MapViewMode.CANVAS_RENDERER); + setMapFile(Settings.getMapFile()); + if (!MapDatabase.isValidMapFile(Settings.getMapFile())) { + Log.e("MapsforgeMapView024: Invalid map file"); + } + Toast.makeText( + getContext(), + getContext().getResources().getString(R.string.warn_deprecated_mapfile), + Toast.LENGTH_LONG) + .show(); + } + + @Override + public void repaintRequired(GeneralOverlay overlay) { + + if (null == overlay) { + invalidate(); + } else { + try { + Overlay ovl = (Overlay) overlay.getOverlayImpl(); + + if (ovl != null) { + ovl.requestRedraw(); + } + + } catch (Exception e) { + Log.e("MapsforgeMapView.repaintRequired: " + e.toString()); + } + } + } + + @Override + public void setOnDragListener(OnMapDragListener onDragListener) { + this.onDragListener = onDragListener; + } + + @Override + public boolean onTouchEvent(MotionEvent ev) { + gestureDetector.onTouchEvent(ev); + return super.onTouchEvent(ev); + } + + private class GestureListener extends SimpleOnGestureListener { + @Override + public boolean onDoubleTap(MotionEvent e) { + if (onDragListener != null) { + onDragListener.onDrag(); + } + return true; + } + + @Override + public boolean onScroll(MotionEvent e1, MotionEvent e2, + float distanceX, float distanceY) { + if (onDragListener != null) { + onDragListener.onDrag(); + } + return super.onScroll(e1, e2, distanceX, distanceY); + } + } + + @Override + public boolean needsInvertedColors() { + return false; + } +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlay.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlay.java new file mode 100644 index 0000000..64ce8b0 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlay.java @@ -0,0 +1,120 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.OtherCachersOverlay; +import cgeo.geocaching.maps.interfaces.ItemizedOverlayImpl; +import cgeo.geocaching.maps.interfaces.MapProjectionImpl; +import cgeo.geocaching.maps.interfaces.MapViewImpl; + +import org.mapsforge.android.mapsold.ItemizedOverlay; +import org.mapsforge.android.mapsold.Projection; + +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Point; +import android.graphics.drawable.Drawable; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class MapsforgeOtherCachersOverlay extends ItemizedOverlay<MapsforgeOtherCachersOverlayItem> implements ItemizedOverlayImpl { + + private OtherCachersOverlay base; + private Lock lock = new ReentrantLock(); + + public MapsforgeOtherCachersOverlay(Context contextIn, Drawable markerIn) { + super(boundCenter(markerIn)); + base = new OtherCachersOverlay(this, contextIn); + } + + @Override + public OtherCachersOverlay getBase() { + return base; + } + + @Override + protected MapsforgeOtherCachersOverlayItem createItem(int i) { + if (base == null) { + return null; + } + + return (MapsforgeOtherCachersOverlayItem) 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 MapsforgeMapProjection(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); + } + + @Override + public void lock() { + lock.lock(); + } + + @Override + public void unlock() { + lock.unlock(); + } + + @Override + public MapViewImpl getMapViewImpl() { + return (MapViewImpl) internalMapView; + } + +}
\ No newline at end of file diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlayItem.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlayItem.java new file mode 100644 index 0000000..29a2b62 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOtherCachersOverlayItem.java @@ -0,0 +1,31 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.go4cache.Go4CacheUser; +import cgeo.geocaching.maps.OtherCachersOverlayItem; +import cgeo.geocaching.maps.interfaces.OtherCachersOverlayItemImpl; + +import org.mapsforge.android.mapsold.GeoPoint; +import org.mapsforge.android.mapsold.OverlayItem; + +import android.content.Context; +import android.graphics.drawable.Drawable; + +public class MapsforgeOtherCachersOverlayItem extends OverlayItem implements OtherCachersOverlayItemImpl { + private final OtherCachersOverlayItem item; + + public MapsforgeOtherCachersOverlayItem(Context context, Go4CacheUser user) { + super(new GeoPoint(user.getCoords().getLatitudeE6(), user.getCoords().getLongitudeE6()), user.getUsername(), ""); + item = new OtherCachersOverlayItem(context, user); + } + + @Override + public Drawable getMarker(int state) { + Drawable marker = item.getMarker(); + setMarker(marker); + return marker; + } + + public Go4CacheUser getUser() { + return item.getUser(); + } +} diff --git a/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOverlay.java b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOverlay.java new file mode 100644 index 0000000..d40b539 --- /dev/null +++ b/main/src/cgeo/geocaching/maps/mapsforge/v024/MapsforgeOverlay.java @@ -0,0 +1,63 @@ +package cgeo.geocaching.maps.mapsforge.v024; + +import cgeo.geocaching.maps.PositionOverlay; +import cgeo.geocaching.maps.ScaleOverlay; +import cgeo.geocaching.maps.interfaces.GeneralOverlay; +import cgeo.geocaching.maps.interfaces.MapViewImpl; +import cgeo.geocaching.maps.interfaces.OverlayImpl; + +import org.mapsforge.android.mapsold.Overlay; +import org.mapsforge.android.mapsold.Projection; + +import android.app.Activity; +import android.graphics.Canvas; +import android.graphics.Point; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class MapsforgeOverlay extends Overlay implements OverlayImpl { + + private GeneralOverlay overlayBase = null; + private Lock lock = new ReentrantLock(); + + public MapsforgeOverlay(Activity activityIn, OverlayImpl.overlayType ovlType) { + + switch (ovlType) { + case PositionOverlay: + overlayBase = new PositionOverlay(activityIn, this); + break; + case ScaleOverlay: + overlayBase = new ScaleOverlay(activityIn, this); + } + } + + @Override + protected void drawOverlayBitmap(Canvas canvas, Point drawPosition, + Projection projection, byte drawZoomLevel) { + + if (overlayBase != null) { + overlayBase.drawOverlayBitmap(canvas, drawPosition, new MapsforgeMapProjection(projection), drawZoomLevel); + } + } + + public GeneralOverlay getBase() { + return overlayBase; + } + + @Override + public void lock() { + lock.lock(); + } + + @Override + public void unlock() { + lock.unlock(); + } + + @Override + public MapViewImpl getMapViewImpl() { + return (MapViewImpl) internalMapView; + } + +} |