Sommario di tre modi per muovere Android View

Introduzione

Nello sviluppo Android, View è sempre stato un problema per gli sviluppatori Android, da una parte desiderano migliorare, dall'altra hanno paura di migliorare, si può dire che la View di Android è il più grande ostacolo sulla strada del miglioramento, poiché coinvolge molte cose, come la nostra View di spostamento di questa volta, inclusi la trasmissione degli eventi di tocco della View, la creazione di View personalizzate, che sono estremamente importanti e inevitabili难题. Ma in qualsiasi modo, le difficoltà che non superiamo ora saranno superate in futuro.

Prima di tutto, è necessario comprendere le regole di definizione del sistema di coordinate di Android e alcuni parametri di posizione di View.

Sistema di coordinate di Android

La posizione e le dimensioni di View sono determinate da quattro parametri, ovvero left, top, right, bottom, e questi quattro parametri sono relativi al View genitore.

int width = right-left;
 int height = bottom-top;

Dopo che la layout è stata completata nell'Activity, possiamo ottenere queste informazioni sui parametri attraverso alcuni metodi di View:

// Ottenimento dei valori left, top, right, bottom
 int left = getLeft();
 int top = getTop();
 int right = getRight();
 int bottom = getBottom();

Inoltre, da Android 3.0 in poi, sono stati aggiunti i parametri x, y, translationX, translationY, ecc. (x, y) rappresentano i valori x, y dell'angolo in alto a sinistra di View nel ViewGroup. translationX, translationY vengono utilizzati per spostare una View. Di default sono entrambi 0 e vengono modificati dopo aver chiamato setTranslationX()/setTranslationY() di View.

// Ottenimento dei parametri x, y, translationX, translationY
 int x = getX();
 int y = getY();
 int translationX = getTranslationX();
 int translationY = getTranslationY();

PS: La chiamata ai metodi setTranslationX() e setTranslationY() di View può far spostare la View di una distanza specificata, ma questo processo viene completato istantaneamente. Per rendere il movimento della View più fluido, è possibile utilizzare l'animazione delle proprietà di View per specificare translationX e translationY.

ObjectAnimator valueAnimator = ObjectAnimator.ofFloat(textView, "translationX", 200);
 valueAnimator.setDuration(2000);
 valueAnimator.start();

Inoltre, se si impostano setTranslationX() e setTranslationY() per View, se il valore impostato non cambia, si muoverà solo una volta, ossia la distanza di spostamento specificata per la prima volta. Dopo aver controllato il codice sorgente, abbiamo scoperto la ragione: dopo aver impostato il valore, confronta il valore impostato con il translationX e translationY corrente, e si muove solo se non sono identici.

Dopo aver compreso alcuni parametri di base di View, guardiamo i tre modi di movimento di View.

Prima di tutto, utilizzare i metodi scrollTo()/scrollBy() forniti dal sistema Android per muovere View.

Sia scrollTo() che scrollBy(), l'essenza del loro movimento è il contenuto di View/ViewGroup, e il processo di movimento è completato istantaneamente. Pertanto, per ottenere un migliore effetto di movimento, è necessario utilizzarlo con la classe Scroller. Inoltre, è diverso dal Translation sopra, che muove View stesso, questo punto deve essere ben compreso.

scrollTo() e scrollBy() sono metodi di View, non metodi di Scroller, ma il controllo dello spostamento fluido di View è strettamente legato alla classe Scroller.

scrollTo() : indica lo spostamento della posizione assoluta, se la posizione non cambia, la chiamata più volte non avrà alcun effetto.

Schema di processo di scrollTo

scrollBy() : la sua essenza rimane quella di chiamare scrollTo() , che indica la distanza relativa di spostamento della posizione corrente (ogni volta che si aggiunge la posizione corrente e la distanza impostata e si chiama scrollTo(), quindi se si chiama più volte, si scoprirà che si muove una distanza ogni volta, che è la differenza fondamentale rispetto a scrollTo())

Schema di processo di scrollBy

PS:Riguardo alle due immagini sopra, in realtà, da sempre, non ho completamente capito cosa siano il relativo e l'assoluto, quindi le due immagini a mano possono essere più facili da capire. Inoltre, ci sono problemi di direzione di movimento di scrollTo() e scrollBy(), abbiamo già disegnato il sistema di coordinate di Android, l'asse x va da sinistra a destra come positivo, l'asse y va da alto a basso come positivo. Tuttavia, questo non si applica a scrollTo e scrollBy, scrollTo e scrollBy sono esattamente opposti, ovvero l'asse x va da sinistra a destra come negativo, l'asse y va da alto a basso come negativo, è veramente un po' ingannevole.

Analisi della classe Scroller: perché utilizzare i metodi della classe Scroller per muovere il contenuto di View/ViewGroup? Proveremo a analizzarlo.

Prima

creiamo un oggetto della classe Scroller mScroller.

Poi

Per far muovere la View a una posizione specifica entro un tempo specificato, chiamiamo il metodo startScroll(), startScroll() è un metodo della classe Scroller, e nella classe Scroller c'è anche un metodo verying() che è molto utilizzato, che principalmente gestisce il movimento fluido, generalmente crea un effetto di inerzia dopo lo scorrimento, rendendo il movimento della View più realistico. Vediamo il codice sorgente di startScroll():

//Accetta quattro/quattro parametri. Se non viene impostato duration, viene utilizzato il valore predefinito. Questi quattro parametri non sono difficili da capire, non è necessario spiegare di più.
 public void startScroll(int startX, int startY, int dx, int dy, int duration) { 
 ...
 }

Di solito chiamiamo questo metodo e poi chiamiamo invalidate() del View, questo metodo può far scattare il metodo draw() della View. E nel draw() viene chiamato computeScroll(), troviamo nel codice sorgente che computeScroll() è un metodo vuoto, ecco perché dobbiamo sovrascrivere il metodo computeScroll(). Poiché l'operazione di movimento reale avviene nel metodo computeScroll().

@Override
 public void computeScroll() {
 if (mScroller.computeScrollOffset()) {
  scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
  //È necessario chiamare postInvalidate()/invalidate() del View, altrimenti il movimento della View sarà solo nel primo frame.
  postInvalidate();
 }
 super.computeScroll();
 }

Sopra abbiamo visto che la classe Scroller ha anche un metodo computeScrollOffset(), ma cosa fa? Il suo principale scopo è determinare se mCurrX e mCurrY sono cambiati, se sì, restituisce true, altrimenti restituisce false. La decisione di questo metodo può determinare se è necessario chiamare continuamente scrollTo() per muovere la View. Ecco un altro esempio, utilizzare scrollTo() per far muovere la View insieme al dito:

public class CuView extends LinearLayout {
 private float mStartX;
 private float mStartY;
 private Scroller mScroller;
 /**
 * La prima scorrimento è completato
 */
 private boolean isFirstFinish;
 public CuView(Context context) {
 super(context);
 init(context);
 }
 public CuView(Context context, AttributeSet attrs) {
 super(context, attrs);
 init(context);
 }
 private void init(Context context) {
 mScroller = new Scroller(context);
 }
 public CuView(Context context, AttributeSet attrs, int defStyleAttr) {
 super(context, attrs, defStyleAttr);
 init(context);
 }
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public CuView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
 super(context, attrs, defStyleAttr, defStyleRes);
 init(context);
 }
 /**
 * Fa seguire al tuo dito la View
 * @param event
 * @return
 */
 @Override
 public boolean onTouchEvent(MotionEvent event) {
 int action = event.getAction();
 switch (action) {
  case MotionEvent.ACTION_DOWN:
  /**
   * Dopo la prima movimentazione, non dobbiamo più prendere la posizione iniziale, altrimenti causerebbe il movimento di View dalla posizione di inizio.
   */
  if (!isFirstFinish) {
   mStartX = event.getRawX();
   mStartY = event.getRawY();
  }
  break;
  case MotionEvent.ACTION_MOVE:
  scrollTo((int) (mStartX - event.getRawX()), (int) (mStartY - event.getRawY()));
  break;
  case MotionEvent.ACTION_UP:
  //Prima movimentazione completata
  isFirstFinish = true;
  break;
 }
 return true;
 }
 /**
 * Test startScroll
 */
 public void startScroll() {
 /**
  * Attenzione alla direzione di movimento del Scroller,
  */
 mScroller.startScroll(20, 20, -500, -500, 5000);
 invalidate();
 }
 @Override
 public void computeScroll() {
 if (mScroller.computeScrollOffset()) {
  scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
  invalidate();
 }
 super.computeScroll();
 }
}

Secondo: utilizzare animazione per realizzare lo spostamento del View.

Questo include l'animazione di tween di View e frame animation, nonché l'animazione di proprietà aggiunta dopo la versione 3.0. Spostano un'immagine di View, la posizione e le dimensioni del View stesso non subiscono alcuna modifica.

Terzo: impostare LayoutParams del View per spostare il View

LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) textView.getLayoutParams();
 layoutParams.leftMargin = 50;
 textView.requestLayout();

Sintesi

Questo è tutto il contenuto della sintesi delle tre modalità di spostamento del View Android, spero che il contenuto di questo articolo possa aiutare tutti a sviluppare Android. Se avete domande, potete lasciare un messaggio per discutere.