Android: Comment faire pivoter un élément en le touchant?

Question

J'essaie de faire pivoter un dessin dans une vue en le touchant et en déplaçant le doigt. J'ai trouvé plusieurs solutions, mais aucune ne semble naturelle sur l'appareil.

Voici ma première approche: Selon l'endroit où l'utilisateur a touché l'écran et dans quelle direction le doigt a été déplacé, je change la rotation de l'étirable, calculée plus ou moins arbitrairement.

private void updateRotation(float x, float y, float oldX, float oldY) { 
    int width = getWidth(); 
    int height = getHeight(); 

    float centerX = width/2; 
    float centerY = height/2; 

    float xSpeed = rotationSpeed(x, oldX, width); 
    float ySpeed = rotationSpeed(y, oldY, height); 

    if ((y < centerY && x > oldX) 
     || (y > centerY && x < oldX)) 
     rotation += xSpeed; 
    else if ((y < centerY && x < oldX) 
      || (y > centerY && x > oldX)) 
     rotation -= xSpeed; 

    if ((x > centerX && y > oldY) 
     || (x < centerX && y < oldY)) 
     rotation += ySpeed; 
    else if ((x > centerX && y < oldY) 
      || (x < centerX && y > oldY)) 
     rotation -= ySpeed; 
} 

private static float rotationSpeed(float pos, float oldPos, float max) { 
    return (Math.abs(pos - oldPos) * 180)/max; 
} 

Cette approche a eu quelques effets secondaires gênants: Parfois, la drawable tournerait alors que le doigt ne bougeait pas et la rotation était généralement pas aussi vite que le doigt de l'utilisateur. J'ai donc jeté ce code et j'ai commencé ma seconde approche. J'utilise la trigonométrie pour calculer la rotation réelle qui serait équivalent au mouvement des doigts:

private void updateRotation(float x, float y, float oldX, float oldY) { 
    float centerX = getWidth()/2; 
    float centerY = getHeight()/2; 

    float a = distance(centerX, centerY, x, y); 
    float b = distance(centerX, centerY, oldX, oldY); 
    float c = distance(x, y, oldX, oldY); 

    double r = Math.acos((Math.pow(a, 2) + Math.pow(b, 2) - Math.pow(c, 2)) 
         /(2 * a * b)); 

    if ((oldY < centerY && x < oldX) 
     || (oldY > centerY && x > oldX) 
     || (oldX > centerX && y < oldY) 
     || (oldX < centerX && y > oldY)) 
     r *= -1; 

    rotation += (int) Math.toDegrees(r); 
} 

private float distance(float x1, float y1, float x2, float y2) { 
    return Math.abs(x1 - x2) + Math.abs(y1 - y2); 
} 

Bien que cela ne semble que pour moi la bonne solution, il ne fonctionne pas bien non plus. Le mouvement des doigts est parfois ignoré - le calcul peut-il être trop coûteux? De plus, la rotation est encore un peu plus rapide que le mouvement réel du doigt.

Idéalement, si je commence à faire tourner l'emboutissage en touchant un point spécifique, ce point devrait rester sous le doigt à tout moment. Pouvez-vous me dire comment y parvenir?

Edit:

Voici mon adoption de la suggestion de Snailer. Je devais passer les arguments pour la méthode atan2 pour tourner dans la bonne direction, maintenant il fonctionne très bien:

private void updateRotation(float x, float y) { 
    double r = Math.atan2(x - getWidth()/2, getHeight()/2 - y); 
    rotation = (int) Math.toDegrees(r); 
} 

Answer 1

Cela peut se faire facilement en obtenant l'angle créé par votre doigt et le centre de l'écran. Semblable à ce que vous avez ci-dessus dans le deuxième exemple. Dans votre onTouchEvent envoyer le getX()/getY() à cette méthode:

private double getDegreesFromTouchEvent(float x, float y){ 
     double delta_x = x - (Screen Width) /2; 
     double delta_y = (Screen Height) /2 - y; 
     double radians = Math.atan2(delta_y, delta_x); 

     return Math.toDegrees(radians); 
    } 

Puis, quand vous dessinez(), vous pouvez simplement tourner la toile selon les résultats. Évidemment, vous devrez utiliser if (MotionEvent.getAction() == MotionEvent.ACTION_MOVE) pour mettre à jour l'angle.