Android multi-touch. How exactly does it work?

[Stephen Bell]

OK Guys, I was wondering if someone would be kind enough to explain exactly how multi-touch works in Android? I've read various blogs and tuts online (including the official developers guide) but I still can't make head nor tails of it.

If I press the screen with one finger, no problem, I also know how to detect a non-primary finger touching the screen.

But if I have say, 2 fingers on the screen and I remove one of them, how can I determine where the remaining finger is on the screen? This is partly what I don't understand.

Where does event.getPointerCount, event.getActionIndex(); & event.getActionMasked(); come into it?

Here is my code: Please see the MotionEvent.ACTION_POINTER_UP: section, this is the part I don't understand - I need to know where the remaining fingers are.

Would be grateful for any help - thanks!!

Code

  @Override
		public boolean onTouchEvent(MotionEvent event) {
			
	     int actionMask = event.getActionMasked();
		int pointerIndex = event.getActionIndex();
		int pointerCount = event.getPointerCount();
	    	
	    	switch (actionMask){
	    	
	    	case MotionEvent.ACTION_DOWN:

                        //If primary finger presses left button, move sprite left
	    		if (event.getX()<=renderer.leftButton("right") && event.getY()>=renderer.leftButton("top")){
	    				renderer.setSpriteState('l', true);
	    				renderer.setSpriteState('r', false);
	    			}
	    	        
                        //If primary finger presses left button, move sprite right
	    		else if (event.getX()>=renderer.rightButton("left") && event.getY()>=renderer.rightButton("top")){
	    				renderer.setSpriteState('r', true);
	    				renderer.setSpriteState('l', false);
	    			}
	    		
                        //If primary finger presses jump button, make sprite jump
	    		else if (event.getX()>=renderer.jumpButton("left") && event.getX()<renderer.jumpButton("right")
	    				&& event.getY()>=renderer.jumpButton("top")){
	    				renderer.setSpriteState('j', true);
	    		}
	    			break;}
	    	                
	    	case MotionEvent.ACTION_POINTER_DOWN:
          
                        //If secondary finger presses left button, move sprite left
	    		if (event.getX(pointerIndex)<=renderer.leftButton("right") && event.getY(pointerIndex)>=renderer.leftButton("top")){
	    			renderer.setSpruteState('l', true);
    				renderer.setSpriteState('r', false);
    			}

                         //If secondary finger presses right button, move sprite left
	    		else if (event.getX(pointerIndex)>=renderer.rightButton("left") && event.getY(pointerIndex)>=renderer.rightButton("top")){
    				renderer.setSpriteState('r', true);
    				renderer.setSpriteState('l', false);
    			}
    		
                        //If secondary finger presses jump button,make sprite jump
	    		else if (event.getX(pointerIndex)>=renderer.jumpButton("left") && event.getX(pointerIndex)<renderer.jumpButton("right")
    				&& event.getY()>=renderer.jumpButton("top")){
    				renderer.setSpriteState('j', true);
    		}
	    			break;}
	    	
	    	case MotionEvent.ACTION_POINTER_UP: {
	    		
	    		//***********************************************
                        //* If a finger (non-primary) is removed from the screen *
                        //*  How do I determine where the remaining ones are?!  *
                       //****************************************	*******    		
	    		
	    	}
	    	
	    	case MotionEvent.ACTION_UP: {
	    		
	    			//Stop Sprite when last finger released
	    			renderer.setSpriteState('l', false);
	    			renderer.setSpriteState('r', false);	    		
	    			break;}
	    	}
	    	
	  
	    	return true;
			// TODO Auto-generated method stub

[Steve Luke]

The MotionEvent keeps track of all the fingers/pointers on the screen. You can keep track the fingers using the getX(int) and getY(int) methods. The integer parameter is the index of the point being tracked. If you want to get the location of the fingers that were not released as part of the ACTION_POINTER_UP action, then you would:
1) Call the getPointerCount() to determine the total number of fingers touching the display. The indeces will be from 0 to the count-1
2) Determine the index of the finger which was released. Use the [tt]getActionIndex() method for that.
3) Loop through all the other indeces using getX(index) and getY(index)

Note: the index of each pointer is not kept constant, so the first finger you put down will not always be index 0, and the third finger to touch the screen won't always be index 2. If you need consistency by finger, then you need to use the pointer id to get the index that you care about.

Stephen Bell wrote:...I also know how to detect a non-primary finger touching the screen.

I think you should disabuse yourself of the notion of a 'primary' finger. The ACTION_DOWN is performed the first time a finger touches the screen (call it A). Then ACTION_POINTER_DOWN if a second finger touches (call it B). If the user releases finger A, then the ACTION_POINTER_UP is sent, because there is still one remaining finger left. And the ACTION_UP is sent when finger B is removed. The ACTION_DOWN and ACTION_UP are used to signify the first finger and last finger, which may not be the same finger. So there is no such thing as a 'primary' finger.

[Stephen Bell]

Hi Steve,

Thanks for this, I've implemented what I think is the correct way of doing this after reading your post but still have a couple of issues - would be grateful if you could advise of what I'm doing wrong!!

I've posted my code below, what happens is that if I press the left button, sprite goes left. If I the press the right (with the left still presses) then it goes right.

If I then release the right button (with the left still pressed from the very beginning, it goes left) but......

Instead of releasing the right button as above, I release the left button with the remaining finger on the right control, the sprite goes left!! I've looked over and over my code but I can't figure out why this could be, I think everything looks OK (I'm checking coordinates of all remaining fingers against the controls).

Would really appreciate if you can spot the error in my code! Thanks again, appreciate it!

	case MotionEvent.ACTION_POINTER_UP:{
				
				//PointerCount contains the number of fingers that were on-screen
				//before finger was lifted (remaining fingers +1)
				//Count through all remaining fingers and check their screen positions
				//Against movement buttons.
				
				for(int i = 0;i<pointerCount-1;i++){
					Log.v("newTouch","Remaining finger ID: "+i);
				
                                //Any of the remaining fingers on the left button?
				
                                if (event.getY(i)>=renderer.leftButton("top") && event.getX(i)<=renderer.leftButton("right")){
				
                                //If so, then move left (or continue to move left)
					renderer.setSpriteState('l', true);
					renderer.setSpriteState('r', false)
					
				}
				
                                 //Any of the remaining fingers on the rightbutton?

				else if (event.getY(i)>=renderer.rightButton("top") && event.getX(i)>=renderer.rightButton("left") && event.getX(i)<=renderer.rightButton("right")){
				//If so, then move left (or continue to move left)
						renderer.setFurmanState('l', false)
						renderer.setFurmanState('r', true)
					
				}
				}

[Steve Luke]

The finder which produced the ACTION_POINTER_UP still counts as a pointer for that event, so its index is included in the pointers you loop through. My guess is when you release out-of-order you end up getting the released finger's index after the other other fingers. This is why I said:

Steve Luke wrote:2) Determine the index of the finger which was released. Use the [tt]getActionIndex() method for that.
3) Loop through all the other indeces using getX(index) and getY(index)

You haven't done anything to avoid processing the released finger as one that is still pressed. So I would suggest you do that.

[Steve Luke]

On the otherhand, I can't help but think this might be easier/more efficient/better if you put touch listeners on the individual buttons, and let the buttons decide when they are pushed, and when they aren't, and handle the cases as such. Maybe something like this:

Button left;
Button right;

//Whererever you build the layout.  Perhaps in an onCreate() method someplace...
//Goal: Get the two buttons, and add touch listeners to handle their down/up states.
        left = //get from layout
        left.setOnTouchListener(new View.OnTouchListener()
        {
            public boolean onTouch(View button, MotionEvent event)
            {
                hanldeLeftButtonPush(event);
                return false;
            }
        };
        
        right = //get from layout
        right.setOnTouchListener(new View.OnTouchListener()
        {
            public boolean onTouch(View button, MotionEvent event)
            {
                hanldeRightButtonPush(event);
                return false;
            }
        };
        
//Methods for handling the Let/Right states more or less independently
    private void goLeft()
    {
        renderer.setSpriteState('r', false);
        renderer.setSpriteState('l', true);
    }
    
    private void goRight()
    {
        renderer.setSpriteState('r', true);
        renderer.setSpriteState('l', false);
    }
    
    private void stopLeft()
    {
        renderer.setSpriteState('l', false);
        
        if (shouldGoRight()
        {
            goRight();
        }
    }
    
    private void stopRight()
    {
        renderer.setSpriteState('r', false);
        
        if (shouldGoLeft()
        {
            goLeft();
        }
    }
    
    private boolean shouldGoLeft()
    {
        return left.isPressed();
    }
    
    private boolean shouldGoRight()
    {
        return right.isPressed();
    }
    
//methods that call the go/stop methods on DOWN/UP actions.

    private void handleLeftButtonPush(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                goLeft();
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                stopLeft();
                break;
            }
        }
    }
    
    private void handleRightButtonPush(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                goRight();
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                stopRight();
                break;
            }
        }
    }

[Stephen Bell]

Thanks again, I thought that when lifting a finger, the index assigned to it was always the most recent (so, three fingers on-screen, any of them is lifted, and 2 is returned).

I can see that I was incorrect in assuming this.

I don't understand therefore, how to discount the finger that was lifted from the screen from my loop?

Any idea how I would achieve this?

Thanks again.

PS thanks for your other suggestion. Unfortunately, I'm not using 'buttons' as such. I'm using graphics that I draw and place on the screen, so I have to do this via screen-coordinates.

[Steve Luke]

Sorry about mis-reading your logic, I didn't notice you were using both < and pointerCount-1. So I thought you were processing all pointers.

Still, I wouldn't make any supposition about pointer index. Rather, get the index of the action, loop through all pointers, and work on the ones that are != the one that is UP. Example:

    int liftedIndex = event.getActionIndex();
    int pointerCount = event.getPointerCount();
    for (int index = 0; index < pointerCount; index++)
    {
        if (index != liftedIndex)
        {
            //do the work
        }
    }

If you have three pointers and two buttons, where are the two remaining pointers located? What happens if one of them is on the same button the released finger is on? Or if they are on different buttons, which direction should the movement go?

[Stephen Bell]

Ah, I see - I never thought of that - I will give it a try and let you know how I get on. You're right about not making suppositions regarding the Pointer Index!

Cheers.

[Stephen Bell]

Success! Thanks very much for this it works, and I have a better understanding now of how multi-touch works on Android! :-)

[Stephen Bell]

Can I ask just one other thing please? How does one go about detecting motion on a secondary pointer? There is no "MotionEvent.ACTION_POINTER_MOVE".

So, when I'm doing something like this:

	case MotionEvent.ACTION_MOVE:{
	    		 int pointerId = event.getPointerId(pointerIndex);
	    		
	    	//Finger slid to left button so set sprite left
	    		if (event.getY(pointerIndex)>=renderer.leftButton("top") && event.getX(pointerIndex)<=renderer.leftButton("right")){
	    			renderer.setSpriteState('l', true);
	    			renderer.setSpriteState('r', false);
	    			
	  		}
	    		
	    		//Finger slide to the right button so set sprite right
	    		else 	
		    		if (event.getY(pointerIndex)>=renderer.rightButton("top") && event.getX(pointerIndex)>renderer.rightButton("left") && event.getX(pointerIndex)<=renderer.rightButton("right")){
		    			renderer.setSpriteState('l', false);
		    			renderer.setSpriteState('r', true);
		    			
		   		}
	    		break;

This works great as long as the finger is the 1st one down, but if it's not, it doesn't pick up the movement (it still monitors the 1st finger only).

if I log event.getActionIndex() it always returns 0 regardless of how many fingers are down (I'm guessing because ACTION_MOVE is only for the initial pointer?

:-(

Cheers

[Steve Luke]

The MOVE action isn't pointer-specific, so if you move all three fingers in a three finger gesture you don't get three events to process. Instead, you need to either get the position of the pointer you care about (by tracking its pointer ID) or you need to cycle through all the pointers to process them all.

I think in your case it would be to process all the pointers and check their current position, but am not positive.

[Stephen Bell]

Hmmmm.... I don't seem to be able to use the pointer ID as it's always returns '0', regardless of how many fingers there are.

So I can't differentiate between fingers/pointers.

Cheers though for your help

[Steve Luke]

No, you get the pointer ids when the _DOWN actions happen, and you store them. Then you do findPointerIndex(pointerId) using the id of the pointer you want info about.

For example, if I wanted to track the last pointer, and make sure that the last pointer down is the one whose button matters, then I would use a stack holding the pointer ids. Each _DOWN event, I would put the new ID on the stack. Then each move I would peek at the top of the stack, get its location, and do the related action. Each _UP event I would remove the id from the stack, then peek at the top of the stack again and do what is there.

If you want to find a particular pointer that moves and do whatever it moves to, you would need to track the pointers and their last button. Then each move you would get each pointer, find which button they are on now, and 'move' it from the old one to the new one if they aren't the same. This wouldn't need a stack: it could be a Map<Integer,Direction> (or button, or something).

Will post again with some example code shortly

[Steve Luke]

Okay, so this is probably more than you need and may not fit into exactly what you are doing. But I was hacking around since the post were you said you weren't using buttons, and I thought 'if this were me, I would have my own class to help encapsulate the 'button' concept, even if it is not the Android Button.' So I made this:

public class Button
{
    private int top, left, width, height;
    
    private int timesPressed;
    
    public Button(int postionTop, int positionLeft, int sizeWidth, int sizeHeight)
    {
        //... fill fields
    }
    
    public boolean isEventInbounds(int x, int y)
    {
        return /* determine inside bounds */;
    }
    
    public void setPressed(boolean pressed)
    {
        if (pressed)
        {
            timesPressed += 1;
        }
        else
        {
            if (timesPressed > 0)
            {
                timesPressed -= 1;
            }
        }
        
    }
    
    public boolean isPressed()
    {
        return this.timesPressed > 0;
    }
}

Now, for this case, I think the only part that is necessary is the fact that there is a public boolean isEventInbounds(int x, int y) method which you can call to check if that button is pressed. I then modified my first bit of code snippet to use this class:

Button left;
Button right;

        Button left = new Button(/* get bounds */);
        Button right = new Button(/* get bounds */);

Then I did some other modifications of my original code:
1) I added a Map to track the Pointer IDs and what button they were last pushing
2) some methods for encapsulating the effects of left/right buttons
3) the OnTouch() method which determines what to do.

For #1, and #2, and #3 before adding the MOVE action, I had this code:

Map<Integer, Button> knownPointerMap = new HashMap<Integer, Button>();

    private void goLeft()
    {
        renderer.setSpriteState('r', false);
        renderer.setSpriteState('l', true);
    }
    
    private void goRight()
    {
        renderer.setSpriteState('r', true);
        renderer.setSpriteState('l', false);
    }
    
    private void stopLeft()
    {
        renderer.setSpriteState('l', false);
        
        if (shouldGoRight()
        {
            goRight();
        }
    }
    
    private void stopRight()
    {
        renderer.setSpriteState('r', false);
        
        if (shouldGoLeft()
        {
            goLeft();
        }
    }
    
    private boolean shouldGoLeft()
    {
        return left.isPressed();
    }
    
    private boolean shouldGoRight()
    {
        return right.isPressed();
    }
    
    private void leftButtonDown(Integer pointerId)
    {
        left.setPressed(true);
        knownPointerMap.put(pointerId, left);
        doLeft();
    }
    
    private void leftButtonUp(Integer pointerId)
    {
        left.setPressed(false);
        knownPointerMap.remove(pointerId);
        stopLeft();
    }
    
    private void rightButtonDown(Integer pointerId)
    {
        right.setPressed(true);
        knownPointerMap.put(pointerId, right);
        doRight();
    }
    
    private void rightButtonUp(Integer pointerId)
    {
        right.setPressed(false);
        knownPointerMap.remove(pointerId);
        stopRight();
    }
        
    private void handleLeftButtonPush(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        int actionIndex = me.getActionIndex();
        Integer pointerId = Integer.valueOf(me.getPointerId(actionIndex));
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                leftButtonDown();
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                leftButtonUp();
                break;
            }
        }
    }
    
    private void handleRightButtonPush(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        int actionIndex = me.getActionIndex();
        Integer pointerId = Integer.valueOf(me.getPointerId(actionIndex));
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                rightButtonDown();
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                rightButtonUp();
                break;
            }
        }
    }
    
    private boolean OnTouch(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        int actionIndex = me.getActionIndex();
        int x = getX(actionIndex);
        int y = getY(actionIndex);
            
        if(left.isEventInBounds(x, y))
        {
            handleLeftButtonPush(me);
        }
        else if (right.isEventInBounds(x, y))
        {
            handleRightButtonPush(me);
        }

        return true;
    }

Lots of code, but the important part is that the handleRightButtonPush() and handleLeftButtonPush() take care of the DOWN and UP actions for each button, delegating to rightButtonUp() rightButtonDown(), leftButtonUp, rightButtonDown() as needed, and the ddddButtonUp/Down() methods take care of adding and removing pointers from the map.

So we have a Map<Integer, Button> which has all the Pointer IDs we care about, and what button they were last associated with. Now we get a MOVE action and need to:
1) Figure out where each pointer is located.
2) Figure out if a pointer left its last known location, and if so register that fact.
3) Figure out if a Pointer entered a new Button location, and if so, register that fact.

To do this, I thought I would have to account for pointers which where down, but not over one of the buttons. So I added the following code to track a 'NONE' button. Basically the same stuff as for the left and right buttons:

/* Use the NONE Button to track pointers that are down, but not over one of the
   known buttons. */
static final Button NONE = new Button(-1, -1, -1, -1);

    private void noneButtonDown(Integer pointerId)
    {
        knownPointerMap.put(pointerId, NONE);
    }
    
    private void noneButtonUp(Integer pointerId)
    {
        knownPointerMap.remove(pointerId);
    }
        
    private void handleNoneButtonPushMotionEvent me)
    {
        int actionMask = me.getActionMasked();
        int actionIndex = me.getActionIndex();
        Integer pointerId = Integer.valueOf(me.getPointerId(actionIndex));
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                noneButtonDown();
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                noneButtonUp();
                break;
            }
        }
    }

Now, I have something to put in the Map so I don't lose track of wandering pointers. Finally I can add MOVE to my onTouch method:

    private boolean OnTouch(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        
        if (actionMask == ACTION_MOVE)
        {
            for (Map.Entry<Integer, Button> pointerEntry : knownPointerMap.EntrySet())
            {
                int pointer = pointerEntry.key();
                Button lastKnownDirection = pointerEntry.value();
                
                int pointerIndex = me.getPointerIndex(pointer);
                int pointerX = me.getX(pointerIndex);
                int pointerY = me.getY(pointerIndex);
                
                if (!lastKnownDirection.isEventInBounds(x, y))
                {
                    //make it so this pointer doesn't count toward the button's
                    //pressed state.
                    lastKnownDirection.setPressed(false);
                    
               /* This may cause ConcurrentModificationException, not sure... */

                    //figure out which button it currently is in (if any)
                    //and do that button's action.  Update the last
                    //known position for this pointer...
                    if (left.isEventInBounds(x,y))
                    {
                        leftButtonDown(pointer);
                    }
                    else if (right.isEventInBounds(x,y))
                    {
                        rightButtonDown(pointer);
                    }
                    else
                    {
                        //not located over either button, but not removed
                        //either, so put it on the NONE button.
                        noneButtonDown(pointer);
                    }
                }
            }
        }
        else
        {
            int actionIndex = me.getActionIndex();
            int x = getX(actionIndex);
            int y = getY(actionIndex);
            
            if(left.isEventInBounds(x, y))
            {
                handleLeftButtonPush(me);
            }
            else if (right.isEventInBounds(x, y))
            {
                handleRightButtonPush(me);
            }
            else
            {
                //Pointer down on a none-button area.  Handle it
                //anyways.
                handleNoneButtonPush(me);
            }
        }

        return true;
    }

So the first half of the method determines if it is a MOVE action. If it is, we will handle it here. If not, then we will delegate to the handleddddButtonPush() methods, like before (but this time, also adding the NONE button push).

In the MOVE section of the method, I iterate all the pointers in the Map - the Map must contain all and only the Pointers I care about since I add/remove them whenever a DOWN/UP action occurs. So I iterate over each one, get its last known button, and check if it still sits on the same button. If it does, no further action is needed. If it does not, I check which button it does sit on and make it do that button's action.

None of the is compiled or tested, so take it as a little more than pseudo code. Also note that I think the way I handle the map in the iterator may lead to a ConcurrentModificationException, but I will let you handle that if it happens.

And like I said, this is so much different than what you have you may just want to take the Map or List idea and ignore 90% of the code

[Stephen Bell]

Wow this is an incredibly detailed piece of code, thanks so much for this. It's gonna take me a while to read through it and understand what does what!

You're right about having a separate class, or at the very least I should have methods like you have for checking that left / right etc have been pressed instead of repeating the same code in every case.

Thanks again, I'm gonna get reading :-)

[Stephen Bell]

Hi Steve, I've looked over the code multiple times but I think it's over my head! I can't seem to follow what's happening in it :-/ think I need something simpler lol

I did manage to 'kind of' get this working using a simple for-loop like so:

case MotionEvent.ACTION_MOVE:{
							
				int index = 0;
				
				for(index=0; index<event.getPointerCount(); index++) {
				 
                                //Is finger on the left button? If so, the go (or continue going) left
				if (event.getY(index)>renderer.leftButton("top")&&event.getX(index)<renderer.leftButton("right")){
					renderer.setSpriteState('l', true);
					renderer.setSpriteState('r', false);}
				
				//Or the right?
				else if (event.getY(index)>renderer.rightButton("top")&& event.getX(index)>renderer.rightButton("left") && event.getX(index)<renderer.rightButton("right")){
					renderer.setSpriteState('l', false);
					renderer.setSpriteState('r', true);}
		        }
				break;			
				
				
				

This works in that it will follow my finger movement whether initial finger or subsequent finger(s), however, the one problem is that if both fingers are held on the buttons (one on the left button and one on the right button), then the sprite is randomly turning left and right (presumably, because tiny movements are being detected and thus it's firing the move code and setting the sprite's direction when it doesn't need to be set).

So I guess my the code I've used is way too simple for this. Guess I have to find middle ground. Any idea how I can stop this happening? I'm guessing saving the position on a 'stack' like you advised, but I just don't get how to achieve this still? I'll keep looking over the code you wrote but if you could possibly break down that particular part I would be really grateful - thank you!

[Steve Luke]

I didn't use a Stack, that was an example for needing 'last finger down' but that isn't your scenario. You need to know only when a pointer (any pointer) moves from one button to the next. So you need to track the pointer and the button it is associated with. That is the job of a Map. Do you know what a Map is?

I will show you the code again, but simpler, and only for the Left button. To simplify things, I will get rid of the Button class. Instead I will use an enum to hold direction. You can use whatever you want but you need to use something that is safe, and enums are safe, easy, and descriptive. That is why I am using them:

/* The two possible movement directions */
public enum Direction
{
    LEFT, RIGHT
}

I then have a Map which holds the known pointers and their last known direction:

/* Holds all known Pointers, and their Direction */
Map<Integer, Direction> knownPointerMap = new HashMap<Integer, Direction>();

I have a couple of methods to start and stop movement in the Left direction:

    /* Sets up left movement */
    private void goLeft()
    {
        renderer.setSpriteState('r', false);
        renderer.setSpriteState('l', true);
    }
    
    /* Stops left movement.  NOTE: unless something else is done, this
       stops ALL movement, because it does not re-start right movement. */
    private void stopLeft()
    {
        renderer.setSpriteState('r', false);
        renderer.setSpriteState('l', false);
    }

I then have methods which handle when the Left button is pushed (DOWN action) and released (UP action):

    /* Handles the case when the Left button is pushed */
    private void leftButtonDown(Integer pointerId)
    {
        knownPointerMap.put(pointerId, Direction.LEFT);
        doLeft();
    }
    
    /* Handles the case when the Left button is released */
    private void leftButtonUp(Integer pointerId)
    {
        knownPointerMap.remove(pointerId);
        stopLeft();
    }

I have a method I extracted from the onTouch method to handle just the actions associated with the Left button:

    /* Hanles DOWN/UP actions on the Left button */
    private void handleLeftButtonPush(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        int actionIndex = me.getActionIndex();
        Integer pointerId = Integer.valueOf(me.getPointerId(actionIndex));
        
        switch(actionMask):
        {
            case ACTION_DOWN:
            case ACTION_POINTER_DOWN:
            {
                leftButtonDown(pointerId);
                break;
            }
            case ACTION_UP:
            case ACTION_POINTER_UP:
            {
                leftButtonUp(pointerId);
                break;
            }
        }
    }

And I have a method I extracted from the onTouch method which handles all non-MOVE actions and determines if the Left button's method should be called:

    /* Handle DOWN/UP actions, in general */
    private void handleNonMoveAction(MotionEvent me)
    {
        int actionIndex = me.getActionIndex();
        int x = getX(actionIndex);
        int y = getY(actionIndex);
        
        if ((y > renderer.leftButton("top")) && 
            (x < renderer.leftButton("right"))
        {
            handleLeftButtonPush(me);
        }
    }

Finally, I have the onTouch method which determines if the non-MOVE action method should be called:

    public boolean onTouch(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        
        if (actionMask != ACTION_MOVE)
        {
            handleNonMoveAction(me);
        }
    }

You should realize that these methods would get called in the reverse order as listed here. The onTouch() is called by the OS, which calls handleNonMoveAction() which calls handleLeftButtonPush() which calls leftButtonDown() which adds to the Map and calls goLeft(). I wrote the methods from the simplest and most specific to the most general.

So, if you put all that code in your project, and fix any compile errors, what you should get is in the simple case (with no finger movement) when the users touches and releases buttons with multiple fingers, the Left movement should be tracked properly. Additionally, behind the scenes, a Map is maintained so we know where the pointers are pointing to.

I think you need to be able to follow that part before continuing onto the MOVE. To prove that you should implement the Right side of the motion. Perhaps take care of the warning I put in the in the stopLeft() method's comments.

The MOVE action I have handled in its own method, like this:

    /* Handle MOVE actions, in general */
    private void handleMoveAction(MotionEvent me)
    {
        // get all pointers
        Set<Integer> allPointers = knownPointerMap.keySet();
        
        // for each pointer...
        for (Integer pointer : allPointers)
        {
            //get its index
            int pointerIndex = me.findPointerIndex(pointer);
            
            //Get its x and y coordinates
            int x = me.getX(pointerIndex);
            int y = me.getY(pointerIndex);
            
            //Get the direction it was pointing last
            Direction lastDirection = knownPointerMap.get(pointer);
            
            //If last direction was Left
            if (lastDirection == Direction.LEFT)
            {
                //If still pointing at Left Button
                if ((y > renderer.leftButton("top")) && 
                    ( x < renderer.leftButton("right"))
                {
                    // do nothing, was pointing at Left, 
                    //             am Pointing at Left, 
                    //             no change needed.
                }
                else
                {
                    //No longer pointing at Left.  Register that fact
                    //             and assuming just two buttons, start
                    //             pointing at Right
                    leftButtonUp(pointer);
                    rightButtonDown(pointer);
                }
            }
        }
    }

I tried to be descriptive of what each part does. Note that this, too, just implements the Left side of things, but assumes the rightButtonDown() method has been created. To integrate this code, you will also nee to change the onTouch() method to:

    public boolean onTouch(MotionEvent me)
    {
        int actionMask = me.getActionMasked();
        
        if (actionMask != ACTION_MOVE)
        {
            handleNonMoveAction(me);
        }
        else
        {
            handleMoveAction(me);
        }
    }

The difference there should be pretty obvious to you.

[Stephen Bell]

I've not used maps in Java before, but.............. I've picked out concepts from your code and spent all day writing a routine to track the pointers and I'm finally there :-)

Well, it appears to work anyway so that's always a major plus!

I definitely now have a better understanding of how multi-touch works on Android, it's definitely more complicated than I initially thought.

Again, thanks so much for your help with this - much appreciated!!

[Steve Luke]

Great, I am glad I could help.