android maps: How to Long Click a Map?

Question

How do I long click on a mapview so that a place marker appears at that point on the map?

I tried a couple ways without success:

1) Using setOnLongClickListener on the MapvView which never detected the longclicks.

2) My other idea was to extend MapView to override dispatchTouchEvent .. Create a GestureDetector to respond to longpress callback. But I was stuck midway here as I could not get a handle to my subclassed Mapview. i.e.

MyMapview mymapview; //MyMapView extends MapView

//results in a classcast exception
mymapView = (MyMapView) findViewById(R.id.map);

3) The only other way I know how to try this is: Detect a MotionEvent.ACTION_DOWN and post a delayed runnable to a handler and detect longpress if the two other events: acton_move or an action_up, have not happened.

Can someone provide thoughts on any of these methods to detect long presses?

Answer 1

This mapview-overlay-manager library is super. The reason onLongPress gets triggered when 'scrolling' is because the library does not take into account multitouch. You can work around this by rejecting onLongPress if there is more than one pointer involved as so:

public void onLongPress(MotionEvent motionEvent, ManagedOverlay arg1) {

    if (motionEvent.getPointerCount() > 1) return;

    ... your logic here ...
}

Answer 2

Best way I know to do this is to use the open source mapview-overlay-manager and use its gesture listener which provides a callback for

public void onLongPress(MotionEvent e, ManagedOverlay overlay)

Answer 3

I also got a ClassCastException when I tried using MyMapView. As a workaround, I created a MyMapView object instead of a MapView object and programmatically added it to the layout, and that worked great.

    MyMapView mapView = new MyMapView(this, this.getString(R.string.APIMapKey));
    mapView.displayZoomControls(false);
    mapView.setClickable(true);
    FrameLayout item = (FrameLayout) findViewById(R.id.getlocationmap);
    item.addView((MapView)mapView);

Answer 4

I've found an even easier way. Just make an overlay as the first overlay in the list that does not draw anything and use it to recognize gestures using the GestureDetector. It should then return true if it handled the event so it doesn't get propagated.

    List<Overlay> overlays = mapView.getOverlays();
    overlays.clear();
    overlays.add(new MapGestureDetectorOverlay(new MyOnGestureListener()));

And here's the class:

public class MapGestureDetectorOverlay extends Overlay implements OnGestureListener {
 private GestureDetector gestureDetector;
 private OnGestureListener onGestureListener;

 public MapGestureDetectorOverlay() {
  gestureDetector = new GestureDetector(this);
 }

 public MapGestureDetectorOverlay(OnGestureListener onGestureListener) {
  this();
  setOnGestureListener(onGestureListener);
 }

 @Override
 public boolean onTouchEvent(MotionEvent event, MapView mapView) {
  if (gestureDetector.onTouchEvent(event)) {
   return true;
  }
  return false;
 }

 @Override
 public boolean onDown(MotionEvent e) {
  if (onGestureListener != null) {
   return onGestureListener.onDown(e);
  }
  return false;
 }

 @Override
 public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
   float velocityY) {
  if (onGestureListener != null) {
   return onGestureListener.onFling(e1, e2, velocityX, velocityY);
  }
  return false;
 }

 @Override
 public void onLongPress(MotionEvent e) {
  if (onGestureListener != null) {
   onGestureListener.onLongPress(e);
  }
 }

 @Override
 public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
   float distanceY) {
  if (onGestureListener != null) {
   onGestureListener.onScroll(e1, e2, distanceX, distanceY);
  }
  return false;
 }

 @Override
 public void onShowPress(MotionEvent e) {
  if (onGestureListener != null) {
   onGestureListener.onShowPress(e);
  }
 }

 @Override
 public boolean onSingleTapUp(MotionEvent e) {
  if (onGestureListener != null) {
   onGestureListener.onSingleTapUp(e);
  }
  return false;
 }

 public boolean isLongpressEnabled() {
  return gestureDetector.isLongpressEnabled();
 }

 public void setIsLongpressEnabled(boolean isLongpressEnabled) {
  gestureDetector.setIsLongpressEnabled(isLongpressEnabled);
 }

 public OnGestureListener getOnGestureListener() {
  return onGestureListener;
 }

 public void setOnGestureListener(OnGestureListener onGestureListener) {
  this.onGestureListener = onGestureListener;
 }
}

Answer 5

This works with your MapActivity and will allow you to:

1. Set your own time threshold for what constitutes a long press on the map (0.8 seconds is good for me).
2. Not interpret a scroll, multi-touch, or non-multi-touch event as a long press. It also let's you set a tolerance for someone's finger to ever so slightly move on the screen as they are holding down a long press.

---

This solution is based on Roger Kristiansen's solution. I added x and y point detection so that scrolling is not seen as a long press. This solution is not as elegant as Roger's because I use class variables and put the code in my existing MapActivity instead of extending MapView and creating a listener like he did. But if you want to stick with his code but have better non-multi-touch support, just take the x and y point stuff out of mine and add it to his.

---

Class variables set at the top of my MapActivity:

//variable for determining long press and then automatically adding a pin to the map
private int minMillisecondThresholdForLongClick = 800;
private long startTimeForLongClick = 0;
private float xScreenCoordinateForLongClick;
private float yScreenCoordinateForLongClick;
private float xtolerance=10;//x pixels that your finger can be off but still constitute a long press
private float ytolerance=10;//y pixels that your finger can be off but still constitute a long press
private float xlow; //actual screen coordinate when you subtract the tolerance
private float xhigh; //actual screen coordinate when you add the tolerance
private float ylow; //actual screen coordinate when you subtract the tolerance
private float yhigh; //actual screen coordinate when you add the tolerance

Add this function in your MapActivity:

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        /* We want to capture the place the user long pressed on the map and add a marker (pin) on the map at that lat/long.
         * This solution:
         *  1. Allows you to set the time threshold for what constitutes a long press
         *  2. Doesn't get fooled by scrolling, multi-touch, or non-multi-touch events

         * Thank you Roger Kind Kristiansen for the main idea
         */     

        //get the action from the MotionEvent: down, move, or up
        int actionType = ev.getAction();

        if (actionType == MotionEvent.ACTION_DOWN) {
            //user pressed the button down so let's initialize the main variables that we care about:
            // later on when the "Action Up" event fires, the "DownTime" should match the "startTimeForLongClick" that we set here  
            // the coordinate on the screen should not change much during the long press
            startTimeForLongClick=ev.getEventTime();
            xScreenCoordinateForLongClick=ev.getX();
            yScreenCoordinateForLongClick=ev.getY();

        } else if (actionType == MotionEvent.ACTION_MOVE) {
            //For non-long press actions, the move action can happen a lot between ACTION_DOWN and ACTION_UP                    
            if (ev.getPointerCount()>1) {
                //easiest way to detect a multi-touch even is if the pointer count is greater than 1
                //next thing to look at is if the x and y coordinates of the person's finger change.
                startTimeForLongClick=0; //instead of a timer, just reset this class variable and in our ACTION_UP event, the DownTime value will not match and so we can reset.                        
            } else {
                //I know that I am getting to the same action as above, startTimeForLongClick=0, but I want the processor
                //to quickly skip over this step if it detects the pointer count > 1 above
                float xmove = ev.getX(); //where is their finger now?                   
                float ymove = ev.getY();
                //these next four values allow you set a tiny box around their finger in case
                //they don't perfectly keep their finger still on a long click.
                xlow = xScreenCoordinateForLongClick - xtolerance;
                xhigh= xScreenCoordinateForLongClick + xtolerance;
                ylow = yScreenCoordinateForLongClick - ytolerance;
                yhigh= yScreenCoordinateForLongClick + ytolerance;
                if ((xmove<xlow || xmove> xhigh) || (ymove<ylow || ymove> yhigh)){
                    //out of the range of an acceptable long press, reset the whole process
                    startTimeForLongClick=0;
                }
            }

        } else if (actionType == MotionEvent.ACTION_UP) {
            //determine if this was a long click:
            long eventTime = ev.getEventTime();
            long downTime = ev.getDownTime(); //this value will match the startTimeForLongClick variable as long as we didn't reset the startTimeForLongClick variable because we detected nonsense that invalidated a long press in the ACTION_MOVE block

            //make sure the start time for the original "down event" is the same as this event's "downTime"
            if (startTimeForLongClick==downTime){ 
                //see if the event time minus the start time is within the threshold
                if ((eventTime-startTimeForLongClick)>minMillisecondThresholdForLongClick){ 
                    //make sure we are at the same spot where we started the long click
                    float xup = ev.getX();                  
                    float yup = ev.getY();
                    //I don't want the overhead of a function call:
                    xlow = xScreenCoordinateForLongClick - xtolerance;
                    xhigh= xScreenCoordinateForLongClick + xtolerance;
                    ylow = yScreenCoordinateForLongClick - ytolerance;
                    yhigh= yScreenCoordinateForLongClick + ytolerance;
                    if ((xup>xlow && xup<xhigh) && (yup>ylow && yup<yhigh)){ 

                        //**** safe to process your code for an actual long press **** 
                        //comment out these next rows after you confirm in logcat that the long press works
                        long totaltime=eventTime-startTimeForLongClick;
                        String strtotaltime=Long.toString(totaltime);                               
                        Log.d("long press detected: ", strtotaltime);


                        /* 
                        //Now get the latitude/longitude of where you clicked.  Replace all the code below if you already know how to translate a screen coordinate to lat/long.  I know it works though.

                        //*****************
                        //I have my map under a tab so I have to account for the tab height and the notification bar at the top of the phone.  
                        // Maybe there are other ways so just ignore this if you already know how to get the lat/long of the pixels that were pressed.
                        int TabHeightAdjustmentPixels=tabHost.getTabWidget().getChildAt(0).getLayoutParams().height;
                        int EntireTabViewHeight = tabHost.getHeight();
                        Display display = getWindowManager().getDefaultDisplay(); 
                        int EntireScreenHeight = display.getHeight();
                        int NotificationBarHeight=EntireScreenHeight-EntireTabViewHeight;
                        //the projection is mapping pixels to where you touch on the screen.
                        Projection proj = mapView.getProjection();
                        GeoPoint loc = proj.fromPixels((int)(ev.getX(ev.getPointerCount()-1)), (int)(ev.getY(ev.getPointerCount()-1)-TabHeightAdjustmentPixels-NotificationBarHeight)); 
                        int longitude=loc.getLongitudeE6();             
                        int latitude=loc.getLatitudeE6();
                        //*****************

                        //**** here's where you add code to: 
                        // put a marker on the map, save the point to your SQLite database, etc
                        */

                    }
                }
            }

        }


        return super.dispatchTouchEvent(ev);
    }

Answer 6

If you're going with the delayed post/message to a handler (a solution I use myself), it can be useful to test if the map has moved, i.e. if mapView.getMapCenter(), mapView.getLatitudeSpan() and mapView.getLongitudeSpan() return the same as when the pointer went down.