Android Déplacer ImageView

J'ai cherché sur le web pour une solution simple pour se déplacer librement d'un ImageView. J'ai enfin trouvé un peu de code qui produit un résultat parfait:

public class MainActivity extends Activity implements View.OnTouchListener {

    private int _xDelta;
    private int _yDelta;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ImageView j = (ImageView)findViewById(R.id.j);

        j.setOnTouchListener(this);

    }

    public boolean onTouch(View view, MotionEvent event) {
        final int X = (int) event.getRawX();
        final int Y = (int) event.getRawY();
        ImageView j = (ImageView)findViewById(R.id.j);
        switch (event.getAction() & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                RelativeLayout.LayoutParams lParams = (RelativeLayout.LayoutParams) view.getLayoutParams();
                _xDelta = (int) (X - j.getTranslationX());
                _yDelta = (int) (Y - j.getTranslationY());
                break;
            case MotionEvent.ACTION_UP:
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                break;
            case MotionEvent.ACTION_POINTER_UP:
                break;
            case MotionEvent.ACTION_MOVE:
                RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) view.getLayoutParams();

                j.setTranslationX(X - _xDelta);
                j.setTranslationY(Y - _yDelta);
                break;
        }

        return true;
    }}

Depuis je ne sais pas vraiment comment mon code fonctionne, je voulais voir si il y avait de meilleures solutions.

OriginalL'auteur ueen | 2013-12-20

Que Google suggère, si vous ciblez les versions d'Android 3.0 et au-dessus, vous pouvez utiliser une DragListener.

Pour le pré-Nid d'abeille versions vous pouvez utiliser quelque chose comme:

//The ‘active pointer’ is the one currently moving our object.
private int mActivePointerId = INVALID_POINTER_ID;
@Override
public boolean onTouchEvent(MotionEvent ev) {
//Let the ScaleGestureDetector inspect all events.
mScaleDetector.onTouchEvent(ev);
final int action = MotionEventCompat.getActionMasked(ev); 
switch (action) { 
case MotionEvent.ACTION_DOWN: {
final int pointerIndex = MotionEventCompat.getActionIndex(ev); 
final float x = MotionEventCompat.getX(ev, pointerIndex); 
final float y = MotionEventCompat.getY(ev, pointerIndex); 
//Remember where we started (for dragging)
mLastTouchX = x;
mLastTouchY = y;
//Save the ID of this pointer (for dragging)
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
break;
}
case MotionEvent.ACTION_MOVE: {
//Find the index of the active pointer and fetch its position
final int pointerIndex = 
MotionEventCompat.findPointerIndex(ev, mActivePointerId);  
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float y = MotionEventCompat.getY(ev, pointerIndex);
//Calculate the distance moved
final float dx = x - mLastTouchX;
final float dy = y - mLastTouchY;
mPosX += dx;
mPosY += dy;
invalidate();
//Remember this touch position for the next move event
mLastTouchX = x;
mLastTouchY = y;
break;
}
case MotionEvent.ACTION_UP: {
mActivePointerId = INVALID_POINTER_ID;
break;
}
case MotionEvent.ACTION_CANCEL: {
mActivePointerId = INVALID_POINTER_ID;
break;
}
case MotionEvent.ACTION_POINTER_UP: {
final int pointerIndex = MotionEventCompat.getActionIndex(ev); 
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex); 
if (pointerId == mActivePointerId) {
//This was our active pointer going up. Choose a new
//active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mLastTouchX = MotionEventCompat.getX(ev, newPointerIndex); 
mLastTouchY = MotionEventCompat.getY(ev, newPointerIndex); 
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
}
break;
}
}       
return true;
}

comme de nouveau suggéré par Google ici.

OriginalL'auteur Thomas Kaliakos

Voici la solution que j'ai obtenu:

private float xCoOrdinate, yCoOrdinate;
view.setOnTouchListener(new View.OnTouchListener() {
Float y1 = 0f, y2 = 0f;
@Override
public boolean onTouch(View v, MotionEvent event) {
Point size = new Point();
getWindowManager().getDefaultDisplay().getSize(size);        
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
//xCoOrdinate = view.getX() - event.getRawX();
yCoOrdinate = view.getY() - event.getRawY();
Float puffer = 0f;
y1 = event.getRawY();
break;
case MotionEvent.ACTION_MOVE:
view.animate().y(event.getRawY() + yCoOrdinate).setDuration(0).start();
//view.animate().x(event.getRawX() + xCoOrdinate).y(event.getRawY() + yCoOrdinate).setDuration(0).start();
break;
case MotionEvent.ACTION_UP:
y2 = event.getRawY();
Float dy = (y2 - y1);
if (dy < 0) { 
//moved up
view.animate().y(size.y / 100 * -40).setDuration(100).start();
} else if (dy > 0) {  
//moved down
view.animate().y(size.y / 2 - view.getHeight() / 2).setDuration(100).start();  
}
break;
}
return false;
}
});

Explication: j'ai seulement besoin de mouvement sur l'axe des y et detection si déplacé vers le haut ou vers le bas. Il est fait par l'animation de la vue au toucher, ce qui a des avantages et des contras (contra: son complexe à détecter d'où la vue est dans l'espace /pro: le point de vue qui bouge et ne semblent seulement être ailleurs), mais s'est avéré mieux pour moi et est assez simple.
Le but ici est de glisser le point de vue et de le ramener à un endroit désiré, de même que vers le bas, de retour à la position initiale, ce résultat est obtenu relativ la taille de l'écran.
Pour moi le code est relativement simple et selfexplainatory, mais s'il vous plaît demander si quoi que ce soit clair.

OriginalL'auteur ueen

0

Comme Vous avez utilisé setTranslationX(), qui est de l'API de niveau 11, il est préférable d'utiliser DragListener. http://developer.android.com/guide/topics/ui/drag-drop.html

OriginalL'auteur Sudhin Philip

Qui est solution de travail

public boolean onTouch(View view, MotionEvent event) {
final int X = (int) event.getRawX();
final int Y = (int) event.getRawY();
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN:
RelativeLayout.LayoutParams lParams = (RelativeLayout.LayoutParams) view
.getLayoutParams();
_xDelta = X - lParams.leftMargin;
_yDelta = Y - lParams.topMargin;
break;
case MotionEvent.ACTION_UP:
break;
case MotionEvent.ACTION_POINTER_DOWN:
break;
case MotionEvent.ACTION_POINTER_UP:
break;
case MotionEvent.ACTION_MOVE:
RelativeLayout.LayoutParams ParamsA = (RelativeLayout.LayoutParams) view
.getLayoutParams();
ParamsA.leftMargin = X - _xDelta;
ParamsA.topMargin = Y - _yDelta;
ParamsA.rightMargin = -250;
ParamsA.bottomMargin = -250;
for (int i = 0; i < balls.size(); i++) {
if (balls.get(i).getTag() != view.getTag()) {
RelativeLayout.LayoutParams ParamsB = (RelativeLayout.LayoutParams) balls
.get(i).getLayoutParams();
Rect b = new Rect(ParamsB.leftMargin,ParamsB.topMargin,ParamsB.rightMargin,ParamsB.bottomMargin);
Rect a = new Rect(ParamsA.leftMargin,ParamsA.topMargin,ParamsA.rightMargin,ParamsA.bottomMargin);
if(a.intersect(b))
{
Toast.makeText(getApplicationContext(), "Collision Detected", Toast.LENGTH_SHORT).show();
}
}
}
view.setLayoutParams(ParamsA);
break;
}
//_root.invalidate();
return true;
}

acclamations.

OriginalL'auteur Ali

Vous devez vous connecter pour publier un commentaire.