add pluggable gesture detection

- extract inner Map.Layers class
- extract inner MapView.Map class -> AndroidMap

vtm/src/org/oscim/core/Task.java

@@ -0,0 +1,23 @@
+package org.oscim.core;
+
+public abstract class Task implements Runnable {
+
+	boolean isCanceled;
+
+	@Override
+	public void run() {
+		run(isCanceled);
+	}
+
+	public void run(boolean canceled) {
+
+	}
+
+	public void cancel() {
+		isCanceled = true;
+	}
+
+	public void reset() {
+		isCanceled = false;
+	}
+}

vtm/src/org/oscim/event/Gesture.java

@@ -0,0 +1,21 @@
+package org.oscim.event;
+
+public interface Gesture {
+
+	static final class Press implements Gesture {
+	}
+
+	static final class LongPress implements Gesture {
+	}
+
+	static final class Tap implements Gesture {
+	}
+
+	static final class DoubleTap implements Gesture {
+	}
+
+	public static Gesture PRESS = new Press();
+	public static Gesture LONG_PRESS = new LongPress();
+	public static Gesture TAP = new Tap();
+	public static Gesture DOUBLE_TAP = new DoubleTap();
+}

vtm/src/org/oscim/event/GestureDetector.java

@@ -0,0 +1,20 @@
+package org.oscim.event;
+
+import org.oscim.map.Map;
+
+public class GestureDetector {
+
+	private final Map mMap;
+
+	public GestureDetector(Map map) {
+		mMap = map;
+	}
+
+	public boolean onTouchEvent(MotionEvent e) {
+		if (e.getAction() == MotionEvent.ACTION_DOWN) {
+			return mMap.handleGesture(Gesture.PRESS, e);
+		}
+
+		return false;
+	}
+}

vtm/src/org/oscim/event/GestureListener.java

@@ -0,0 +1,7 @@
+package org.oscim.event;
+
+public interface GestureListener {
+
+	boolean onGesture(Gesture g, MotionEvent e);
+
+}

vtm/src/org/oscim/event/TouchListener.java

@@ -1,11 +0,0 @@
-package org.oscim.event;
-
-import org.oscim.core.MapPosition;
-
-public interface TouchListener {
-	boolean onPress(MotionEvent e, MapPosition pos);
-
-	boolean onLongPress(MotionEvent e, MapPosition pos);
-
-	boolean onTap(MotionEvent e, MapPosition pos);
-}

vtm/src/org/oscim/layers/marker/ItemizedIconLayer.java

@@ -18,15 +18,15 @@ package org.oscim.layers.marker;
 import java.util.List;
 
 import org.oscim.core.BoundingBox;
-import org.oscim.core.MapPosition;
 import org.oscim.core.Point;
+import org.oscim.event.Gesture;
+import org.oscim.event.GestureListener;
 import org.oscim.event.MotionEvent;
-import org.oscim.event.TouchListener;
 import org.oscim.map.Map;
 import org.oscim.map.Viewport;
 
 public class ItemizedIconLayer<Item extends MarkerItem> extends ItemizedLayer<Item>
-        implements TouchListener {
+        implements GestureListener {
 	//static final Logger log = LoggerFactory.getLogger(ItemizedIconOverlay.class);
 
 	protected final List<Item> mItemList;
@@ -108,13 +108,13 @@ public class ItemizedIconLayer<Item extends MarkerItem> extends ItemizedLayer<It
 	 * easily override behavior without resorting to overriding the
 	 * ItemGestureListener methods.
 	 */
-	@Override
-	public boolean onTap(MotionEvent event, MapPosition pos) {
-		return activateSelectedItems(event, mActiveItemSingleTap);
-	}
+	//	@Override
+	//	public boolean onTap(MotionEvent event, MapPosition pos) {
+	//		return activateSelectedItems(event, mActiveItemSingleTap);
+	//	}
 
 	protected boolean onSingleTapUpHelper(int index, Item item) {
-		return this.mOnItemGestureListener.onItemSingleTapUp(index, item);
+		return mOnItemGestureListener.onItemSingleTapUp(index, item);
 	}
 
 	private final ActiveItem mActiveItemSingleTap = new ActiveItem() {
@@ -128,30 +128,30 @@ public class ItemizedIconLayer<Item extends MarkerItem> extends ItemizedLayer<It
 		}
 	};
 
-	@Override
-	public boolean onLongPress(MotionEvent event, MapPosition pos) {
-		return activateSelectedItems(event, mActiveItemLongPress);
-	}
+	//	@Override
+	//	public boolean onLongPress(MotionEvent event, MapPosition pos) {
+	//		return activateSelectedItems(event, mActiveItemLongPress);
+	//	}
 
-	protected boolean onLongPressHelper(int index, Item item) {
-		return this.mOnItemGestureListener.onItemLongPress(index, item);
-	}
+	//	protected boolean onLongPressHelper(int index, Item item) {
+	//		return this.mOnItemGestureListener.onItemLongPress(index, item);
+	//	}
+	//
+	//	private final ActiveItem mActiveItemLongPress = new ActiveItem() {
+	//		@Override
+	//		public boolean run(final int index) {
+	//			final ItemizedIconLayer<Item> that = ItemizedIconLayer.this;
+	//			if (that.mOnItemGestureListener == null) {
+	//				return false;
+	//			}
+	//			return onLongPressHelper(index, getItem(index));
+	//		}
+	//	};
 
-	private final ActiveItem mActiveItemLongPress = new ActiveItem() {
-		@Override
-		public boolean run(final int index) {
-			final ItemizedIconLayer<Item> that = ItemizedIconLayer.this;
-			if (that.mOnItemGestureListener == null) {
-				return false;
-			}
-			return onLongPressHelper(index, getItem(index));
-		}
-	};
-
-	@Override
-	public boolean onPress(MotionEvent e, MapPosition pos) {
-		return false;
-	}
+	//	@Override
+	//	public boolean onPress(MotionEvent e, MapPosition pos) {
+	//		return false;
+	//	}
 
 	/**
 	 * When a content sensitive action is performed the content item needs to be
@@ -164,7 +164,7 @@ public class ItemizedIconLayer<Item extends MarkerItem> extends ItemizedLayer<It
 	 *            ..
 	 * @return true if event is handled false otherwise
 	 */
-	private boolean activateSelectedItems(MotionEvent event, ActiveItem task) {
+	protected boolean activateSelectedItems(MotionEvent event, ActiveItem task) {
 		int size = mItemList.size();
 		if (size == 0)
 			return false;
@@ -232,4 +232,12 @@ public class ItemizedIconLayer<Item extends MarkerItem> extends ItemizedLayer<It
 	public static interface ActiveItem {
 		public boolean run(int aIndex);
 	}
+
+	@Override
+	public boolean onGesture(Gesture g, MotionEvent e) {
+		if (g instanceof Gesture.Tap)
+			return activateSelectedItems(e, mActiveItemSingleTap);
+
+		return false;
+	}
 }

vtm/src/org/oscim/map/Layers.java

@@ -0,0 +1,149 @@
+package org.oscim.map;
+
+import java.util.AbstractList;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.oscim.event.Gesture;
+import org.oscim.event.GestureListener;
+import org.oscim.event.MotionEvent;
+import org.oscim.layers.Layer;
+import org.oscim.map.Map.InputListener;
+import org.oscim.map.Map.UpdateListener;
+import org.oscim.renderer.LayerRenderer;
+
+public final class Layers extends AbstractList<Layer> {
+
+	private final CopyOnWriteArrayList<Layer> mLayerList;
+	private final Map mMap;
+
+	private boolean mDirtyLayers;
+	private LayerRenderer[] mLayerRenderer;
+	private Layer[] mLayers;
+
+	Layers(Map map) {
+		mMap = map;
+		mLayerList = new CopyOnWriteArrayList<Layer>();
+	}
+
+	@Override
+	public synchronized Layer get(int index) {
+		return mLayerList.get(index);
+	}
+
+	@Override
+	public synchronized int size() {
+		return mLayerList.size();
+	}
+
+	@Override
+	public synchronized void add(int index, Layer layer) {
+		if (mLayerList.contains(layer))
+			throw new IllegalArgumentException("layer added twice");
+
+		if (layer instanceof UpdateListener)
+			mMap.bind((UpdateListener) layer);
+		//if (layer instanceof InputListener)
+		//	mMap.bind((InputListener) layer);
+
+		mLayerList.add(index, layer);
+		mDirtyLayers = true;
+	}
+
+	@Override
+	public synchronized Layer remove(int index) {
+		mDirtyLayers = true;
+
+		Layer remove = mLayerList.remove(index);
+
+		if (remove instanceof UpdateListener)
+			mMap.unbind((UpdateListener) remove);
+		//if (remove instanceof InputListener)
+		//	mMap.unbind((InputListener) remove);
+
+		return remove;
+	}
+
+	@Override
+	public synchronized Layer set(int index, Layer layer) {
+		if (mLayerList.contains(layer))
+			throw new IllegalArgumentException("layer added twice");
+
+		mDirtyLayers = true;
+		Layer remove = mLayerList.set(index, layer);
+
+		// unbind replaced layer
+		if (remove instanceof UpdateListener)
+			mMap.unbind((UpdateListener) remove);
+		//if (remove instanceof InputListener)
+		//	mMap.unbind((InputListener) remove);
+
+		return remove;
+	}
+
+	/**
+	 * Should only be used by MapRenderer.
+	 * 
+	 * @return the current LayerRenderer as array.
+	 * */
+	public LayerRenderer[] getLayerRenderer() {
+		if (mDirtyLayers)
+			updateLayers();
+
+		return mLayerRenderer;
+	}
+
+	void destroy() {
+		if (mDirtyLayers)
+			updateLayers();
+
+		for (Layer o : mLayers)
+			o.onDetach();
+
+		// TODO need to clear lists here?
+	}
+
+	boolean handleGesture(Gesture g, MotionEvent e) {
+		if (mDirtyLayers)
+			updateLayers();
+
+		for (Layer o : mLayers)
+			if (o instanceof GestureListener)
+				if (((GestureListener) o).onGesture(g, e))
+					return true;
+
+		return false;
+	}
+
+	void handleMotionEvent(MotionEvent e) {
+		if (mDirtyLayers)
+			updateLayers();
+
+		for (Layer o : mLayers)
+			if (o instanceof InputListener)
+				((InputListener) o).onMotionEvent(e);
+	}
+
+	private synchronized void updateLayers() {
+		mLayers = new Layer[mLayerList.size()];
+		int numRenderLayers = 0;
+
+		for (int i = 0, n = mLayerList.size(); i < n; i++) {
+			Layer o = mLayerList.get(i);
+
+			if (o.getRenderer() != null)
+				numRenderLayers++;
+			mLayers[i] = o;
+		}
+
+		mLayerRenderer = new LayerRenderer[numRenderLayers];
+
+		for (int i = 0, cnt = 0, n = mLayerList.size(); i < n; i++) {
+			Layer o = mLayerList.get(i);
+			LayerRenderer l = o.getRenderer();
+			if (l != null)
+				mLayerRenderer[cnt++] = l;
+		}
+
+		mDirtyLayers = false;
+	}
+}

vtm/src/org/oscim/map/Map.java

@@ -14,19 +14,16 @@
  */
 package org.oscim.map;
 
-import java.util.AbstractList;
 import java.util.LinkedHashSet;
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArrayList;
 
-import org.oscim.core.BoundingBox;
 import org.oscim.core.MapPosition;
+import org.oscim.event.Gesture;
+import org.oscim.event.GestureDetector;
 import org.oscim.event.MotionEvent;
-import org.oscim.layers.Layer;
 import org.oscim.layers.MapEventLayer;
 import org.oscim.layers.tile.bitmap.BitmapTileLayer;
 import org.oscim.layers.tile.vector.VectorTileLayer;
-import org.oscim.renderer.LayerRenderer;
 import org.oscim.renderer.MapRenderer;
 import org.oscim.theme.IRenderTheme;
 import org.oscim.theme.InternalRenderTheme;
@@ -71,10 +68,11 @@ public abstract class Map {
 
 	protected boolean mClearMap;
 	protected final MapEventLayer mEventLayer;
+	protected GestureDetector mGestureDetector;
 
 	private VectorTileLayer mBaseLayer;
 
-	private Set<InputListener> mMotionListeners = new LinkedHashSet<InputListener>();
+	private Set<InputListener> mInputListeners = new LinkedHashSet<InputListener>();
 	private Set<UpdateListener> mUpdateListeners = new LinkedHashSet<UpdateListener>();
 
 	public Map() {
@@ -83,11 +81,13 @@ public abstract class Map {
 		mAnimator = new MapAnimator(this, mViewport);
 
 		mMapPosition = new MapPosition();
-		mLayers = new Layers();
+		mLayers = new Layers(this);
 		mAsyncExecutor = new AsyncExecutor(2);
 
 		mEventLayer = new MapEventLayer(this);
 		mLayers.add(0, mEventLayer);
+
+		//mGestureDetector = new GestureDetector(this, mLayers);
 	}
 
 	public MapEventLayer getEventLayer() {
@@ -254,27 +254,24 @@ public abstract class Map {
 	}
 
 	/**
-	 * @return estimated visible axis aligned bounding box
+	 * @return MapAnimator instance
 	 */
-	public BoundingBox getBoundingBox() {
-		return mViewport.getViewBox();
-	}
-
 	public MapAnimator getAnimator() {
 		return mAnimator;
 	}
 
+	/**
+	 * Register InputListener
+	 */
 	public void bind(InputListener listener) {
-		mMotionListeners.add(listener);
+		mInputListeners.add(listener);
 	}
 
+	/**
+	 * Unregister InputListener
+	 */
 	public void unbind(InputListener listener) {
-		mMotionListeners.remove(listener);
-	}
-
-	public void handleMotionEvent(MotionEvent e) {
-		for (InputListener l : mMotionListeners)
-			l.onMotionEvent(e);
+		mInputListeners.remove(listener);
 	}
 
 	/**
@@ -291,115 +288,16 @@ public abstract class Map {
 		mUpdateListeners.remove(l);
 	}
 
-	public final class Layers extends AbstractList<Layer> {
+	// TODO make protected
+	public void handleMotionEvent(MotionEvent e) {
+		mLayers.handleMotionEvent(e);
 
-		private final CopyOnWriteArrayList<Layer> mLayerList;
-
-		Layers() {
-			mLayerList = new CopyOnWriteArrayList<Layer>();
-		}
-
-		@Override
-		public synchronized Layer get(int index) {
-			return mLayerList.get(index);
-		}
-
-		@Override
-		public synchronized int size() {
-			return mLayerList.size();
-		}
-
-		@Override
-		public synchronized void add(int index, Layer layer) {
-			if (mLayerList.contains(layer))
-				throw new IllegalArgumentException("layer added twice");
-
-			if (layer instanceof UpdateListener)
-				bind((UpdateListener) layer);
-			if (layer instanceof InputListener)
-				bind((InputListener) layer);
-
-			mLayerList.add(index, layer);
-			mDirtyLayers = true;
-		}
-
-		@Override
-		public synchronized Layer remove(int index) {
-			mDirtyLayers = true;
-
-			Layer remove = mLayerList.remove(index);
-
-			if (remove instanceof UpdateListener)
-				unbind((UpdateListener) remove);
-			if (remove instanceof InputListener)
-				unbind((InputListener) remove);
-
-			return remove;
-		}
-
-		@Override
-		public synchronized Layer set(int index, Layer layer) {
-			if (mLayerList.contains(layer))
-				throw new IllegalArgumentException("layer added twice");
-
-			mDirtyLayers = true;
-			Layer remove = mLayerList.set(index, layer);
-
-			// unbind replaced layer
-			if (remove instanceof UpdateListener)
-				unbind((UpdateListener) remove);
-			if (remove instanceof InputListener)
-				unbind((InputListener) remove);
-
-			return remove;
-		}
-
-		private boolean mDirtyLayers;
-		private LayerRenderer[] mLayerRenderer;
-
-		public LayerRenderer[] getLayerRenderer() {
-			if (mDirtyLayers)
-				updateLayers();
-
-			return mLayerRenderer;
-		}
-
-		public void destroy() {
-			if (mDirtyLayers)
-				updateLayers();
-
-			for (Layer o : mLayers)
-				o.onDetach();
-		}
-
-		Layer[] mLayers;
-
-		private synchronized void updateLayers() {
-			if (!mDirtyLayers)
-				return;
-
-			mLayers = new Layer[mLayerList.size()];
-
-			int numRenderLayers = 0;
-
-			for (int i = 0, n = mLayerList.size(); i < n; i++) {
-				Layer o = mLayerList.get(i);
-
-				if (o.getRenderer() != null)
-					numRenderLayers++;
-				mLayers[i] = o;
-			}
-
-			mLayerRenderer = new LayerRenderer[numRenderLayers];
-
-			for (int i = 0, cntR = 0, n = mLayerList.size(); i < n; i++) {
-				Layer o = mLayerList.get(i);
-				LayerRenderer l = o.getRenderer();
-				if (l != null)
-					mLayerRenderer[cntR++] = l;
-			}
-
-			mDirtyLayers = false;
-		}
+		for (InputListener l : mInputListeners)
+			l.onMotionEvent(e);
 	}
+
+	public boolean handleGesture(Gesture g, MotionEvent e) {
+		return mLayers.handleGesture(g, e);
+	}
+
 }