Impostare i limiti dello scorrimento di un'immagine senza far ricorso alla Matrix.

Cerchiamo di capire questa formula del Math.max.

 x = Math.max(AXIS_X_MIN, Math.min(x, AXIS_X_MAX - curWidth));
 y = Math.max(AXIS_Y_MIN + curHeight, Math.min(y, AXIS_Y_MAX));

AXIS_X_MIN sarebbe il numero minimo sull'asse delle X. La funzione Math.max sceglie il massimo fra questo valore minimo e un altro valore, che è Math.min(x, AXIS_X_MAX - curWidth).
Dobbiamo interpretare questo, adesso.
Sceglie il valore minimo fra la x corrente e la larghezza, credo, della larghezza di un rettangolo.
Se la x corrente è bassa, viene scelta come valore dalla funzione Math.min.
Se la x comincia a crescere, quando raggiunge il valore di AXIS_X_MAX - curWidth non viene più scelta, ma viene scelta la X.
Questo potrebbe essere un modo per limitare lo scorrimento di un'immagine in una finestra senza far ricorso alle matrici come ho fatto io...

Se infatti io imposto che x è uguale a x se però la x è inferiore a un certo valore, altrimenti è uguale a quel valore, il problema dovrebbe essere risolto in modo molto semplice e senza scomodare matrici varie...

Math.max invece serve per rendere la x uguale a x nel caso in cui questa sia superiore al valore minimo, ossia AXIS_X_MIN.
Ci potrebbe essere un problema nel caso in cui la x sia maggiore del valore massimo considerato, perché verrebbe scelto questo, ma è un falso problema, perché questo è considerato solo se la x tende a eccederlo.

Ho capito la formula!

Ora provo a costruire una limitazione dei movimenti semplicemente per mezzo di quella funzione che non coinvolgeva la Matrix ma era molto più semplice.

---

   OnTouchListener onTouchListener =new View.OnTouchListener() {
   
    int X,Y;
   @Override
   public boolean onTouch(View v, MotionEvent event) {
    
    int action=event.getAction();
    switch(action & MotionEvent.ACTION_MASK){
    case MotionEvent.ACTION_DOWN:
     X=(int)event.getX();
     Y=(int)event.getY();
     
     break;
    case MotionEvent.ACTION_MOVE:
     int currentX=(int)event.getX();
     int currentY=(int)event.getY();
     v.scrollBy(X-currentX, Y-currentY);
     X=currentX;
     Y=currentY;
     break;
    }
    return true;
   }
  };
  imageView.setOnTouchListener(onTouchListener);

Ecco, questo è il semplicissimo modellino di un'immagine scrollabile.
Però ora dobbiamo provare a metterci dei limiti secondo quanto visto con la formula di cui sopra.

   OnTouchListener onTouchListener =new View.OnTouchListener() {
   int fetta=50;
   int X,Y;
   @Override
   public boolean onTouch(View v, MotionEvent event) {
    
    int action=event.getAction();
    switch(action & MotionEvent.ACTION_MASK){
    case MotionEvent.ACTION_DOWN:
     X=(int)event.getX();
     Y=(int)event.getY();
     
     break;
    case MotionEvent.ACTION_MOVE:
     int currentX=(int)Math.max(fetta,Math.min(event.getX(),v.getWidth()-fetta));
     int currentY=(int)Math.max(fetta,Math.min(event.getY(),v.getWidth()-fetta));
     v.scrollBy(X-currentX, Y-currentY);
     X=currentX;
     Y=currentY;
     break;
    }
    return true;
   }
  };
  imageView.setOnTouchListener(onTouchListener);

Funziona egregiamente!

---

Studiamo lo scaling, adesso...

private class ScaleListener 
        extends ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        mScaleFactor *= detector.getScaleFactor();

        // Don't let the object get too small or too large.
        mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 5.0f));

        invalidate();
        return true;
    }
}

che cosa è mScaleFactor?
Andiamo a cercarci la definizione...

private float mScaleFactor = 1.f;

che non aggiunge niente... vediamo come viene usato.

 canvas.scale(mScaleFactor, mScaleFactor);

Ora, sul canvas sono ancora poco esperto.
Ma sarebbe il fattore scala...

Come posso usarlo qui?
Proviamo...

Con una matrix è l'unico modo che mi venga in mente...