Detectar desplazamiento hacia arriba y desplazarse hacia abajo en ListView

Tengo el siguiente requisito:

  • En primer lugar, los datos de la página no: 2 se extraen del servidor y los elementos se rellenan en un ListView.

Teniendo en cuenta que tanto la página anterior como la siguiente están disponibles en un escenario, se ha agregado el siguiente código:

if(prevPageNo > 0){ mListViewActual.setOnScrollListener(this); } if(nextPageNo > 0){ mListViewActual.setOnScrollListener(this); } 

¿Qué condiciones debo poner para detectar scroll up & scroll down en los siguientes métodos:

  1. Void onScroll (vista de AbsListView, int firstVisibleItem, int visibleItemCount, int totalItemCount)
  2. Void onScrollStateChanged (vista de AbsListView, int scrollState)

Después de la acción: se desplaza hacia arriba y se desplaza hacia abajo, por consiguiente se llamará un servicio con la página anterior no o la página siguiente no, para recuperar los elementos que se van a rellenar en el ListView.

Cualquier entrada será útil.

Pasó a través de los siguientes enlaces pero no devolvió la acción de desplazamiento hacia arriba / hacia abajo:

Enlace 1 enlace 2

Intente usar el setOnScrollListener e implemente el onScrollStateChanged con scrollState

 setOnScrollListener(new OnScrollListener(){ public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { // TODO Auto-generated method stub } public void onScrollStateChanged(AbsListView view, int scrollState) { // TODO Auto-generated method stub final ListView lw = getListView(); if(scrollState == 0) Log.i("a", "scrolling stopped..."); if (view.getId() == lw.getId()) { final int currentFirstVisibleItem = lw.getFirstVisiblePosition(); if (currentFirstVisibleItem > mLastFirstVisibleItem) { mIsScrollingUp = false; Log.i("a", "scrolling down..."); } else if (currentFirstVisibleItem < mLastFirstVisibleItem) { mIsScrollingUp = true; Log.i("a", "scrolling up..."); } mLastFirstVisibleItem = currentFirstVisibleItem; } } }); 

Aquí está una versión modificada de trabajo de algunas de las soluciones indicadas anteriormente.

Añadir otra clase ListView:

 package com.example.view; import android.content.Context; import android.util.AttributeSet; import android.view.View; import android.widget.AbsListView; public class ListView extends android.widget.ListView { private OnScrollListener onScrollListener; private OnDetectScrollListener onDetectScrollListener; public ListView(Context context) { super(context); onCreate(context, null, null); } public ListView(Context context, AttributeSet attrs) { super(context, attrs); onCreate(context, attrs, null); } public ListView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); onCreate(context, attrs, defStyle); } @SuppressWarnings("UnusedParameters") private void onCreate(Context context, AttributeSet attrs, Integer defStyle) { setListeners(); } private void setListeners() { super.setOnScrollListener(new OnScrollListener() { private int oldTop; private int oldFirstVisibleItem; @Override public void onScrollStateChanged(AbsListView view, int scrollState) { if (onScrollListener != null) { onScrollListener.onScrollStateChanged(view, scrollState); } } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if (onScrollListener != null) { onScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount); } if (onDetectScrollListener != null) { onDetectedListScroll(view, firstVisibleItem); } } private void onDetectedListScroll(AbsListView absListView, int firstVisibleItem) { View view = absListView.getChildAt(0); int top = (view == null) ? 0 : view.getTop(); if (firstVisibleItem == oldFirstVisibleItem) { if (top > oldTop) { onDetectScrollListener.onUpScrolling(); } else if (top < oldTop) { onDetectScrollListener.onDownScrolling(); } } else { if (firstVisibleItem < oldFirstVisibleItem) { onDetectScrollListener.onUpScrolling(); } else { onDetectScrollListener.onDownScrolling(); } } oldTop = top; oldFirstVisibleItem = firstVisibleItem; } }); } @Override public void setOnScrollListener(OnScrollListener onScrollListener) { this.onScrollListener = onScrollListener; } public void setOnDetectScrollListener(OnDetectScrollListener onDetectScrollListener) { this.onDetectScrollListener = onDetectScrollListener; } } 

Y una interfaz:

 public interface OnDetectScrollListener { void onUpScrolling(); void onDownScrolling(); } 

Y, finalmente, cómo utilizar:

 com.example.view.ListView listView = (com.example.view.ListView) findViewById(R.id.list); listView.setOnDetectScrollListener(new OnDetectScrollListener() { @Override public void onUpScrolling() { /* do something */ } @Override public void onDownScrolling() { /* do something */ } }); 

En su diseño XML:

 <com.example.view.ListView android:id="@+id/list" android:layout_width="match_parent" android:layout_height="match_parent"/> 

Este es mi primer tema, no me juzguen duramente. =)

Esta es una implementación sencilla:

 lv.setOnScrollListener(new OnScrollListener() { private int mLastFirstVisibleItem; @Override public void onScrollStateChanged(AbsListView view, int scrollState) { } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if(mLastFirstVisibleItem<firstVisibleItem) { Log.i("SCROLLING DOWN","TRUE"); } if(mLastFirstVisibleItem>firstVisibleItem) { Log.i("SCROLLING UP","TRUE"); } mLastFirstVisibleItem=firstVisibleItem; } }); 

Y si necesita más precisión, puede utilizar esta clase ListView personalizada:

 import android.content.Context; import android.util.AttributeSet; import android.view.View; import android.widget.AbsListView; import android.widget.ListView; /** * Created by root on 26/05/15. */ public class ScrollInterfacedListView extends ListView { private OnScrollListener onScrollListener; private OnDetectScrollListener onDetectScrollListener; public ScrollInterfacedListView(Context context) { super(context); onCreate(context, null, null); } public ScrollInterfacedListView(Context context, AttributeSet attrs) { super(context, attrs); onCreate(context, attrs, null); } public ScrollInterfacedListView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); onCreate(context, attrs, defStyle); } @SuppressWarnings("UnusedParameters") private void onCreate(Context context, AttributeSet attrs, Integer defStyle) { setListeners(); } private void setListeners() { super.setOnScrollListener(new OnScrollListener() { private int oldTop; private int oldFirstVisibleItem; @Override public void onScrollStateChanged(AbsListView view, int scrollState) { if (onScrollListener != null) { onScrollListener.onScrollStateChanged(view, scrollState); } } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if (onScrollListener != null) { onScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount); } if (onDetectScrollListener != null) { onDetectedListScroll(view, firstVisibleItem); } } private void onDetectedListScroll(AbsListView absListView, int firstVisibleItem) { View view = absListView.getChildAt(0); int top = (view == null) ? 0 : view.getTop(); if (firstVisibleItem == oldFirstVisibleItem) { if (top > oldTop) { onDetectScrollListener.onUpScrolling(); } else if (top < oldTop) { onDetectScrollListener.onDownScrolling(); } } else { if (firstVisibleItem < oldFirstVisibleItem) { onDetectScrollListener.onUpScrolling(); } else { onDetectScrollListener.onDownScrolling(); } } oldTop = top; oldFirstVisibleItem = firstVisibleItem; } }); } @Override public void setOnScrollListener(OnScrollListener onScrollListener) { this.onScrollListener = onScrollListener; } public void setOnDetectScrollListener(OnDetectScrollListener onDetectScrollListener) { this.onDetectScrollListener = onDetectScrollListener; } public interface OnDetectScrollListener { void onUpScrolling(); void onDownScrolling(); } } 

Un ejemplo de uso: (no olvide añadirlo como una etiqueta Xml en su layout.xml)

 scrollInterfacedListView.setOnDetectScrollListener(new ScrollInterfacedListView.OnDetectScrollListener() { @Override public void onUpScrolling() { //Do your thing } @Override public void onDownScrolling() { //Do your thing } }); 
  ListView listView = getListView(); listView.setOnScrollListener(new OnScrollListener() { @Override public void onScrollStateChanged(AbsListView view, int scrollState) { view.setOnTouchListener(new OnTouchListener() { private float mInitialX; private float mInitialY; @Override public boolean onTouch(View v, MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN: mInitialX = event.getX(); mInitialY = event.getY(); return true; case MotionEvent.ACTION_MOVE: final float x = event.getX(); final float y = event.getY(); final float yDiff = y - mInitialY; if (yDiff > 0.0) { Log.d(tag, "SCROLL DOWN"); scrollDown = true; break; } else if (yDiff < 0.0) { Log.d(tag, "SCROLL up"); scrollDown = true; break; } break; } return false; } }); 

Con todo el método publicado, hay problemas para reconocer cuando el usuario se desplaza hacia arriba desde el primer elemento o hacia abajo desde el último. Aquí hay otro enfoque para detectar desplazamiento arriba / abajo:

  listView.setOnTouchListener(new View.OnTouchListener() { float height; @Override public boolean onTouch(View v, MotionEvent event) { int action = event.getAction(); float height = event.getY(); if(action == MotionEvent.ACTION_DOWN){ this.height = height; }else if(action == MotionEvent.ACTION_UP){ if(this.height < height){ Log.v(TAG, "Scrolled up"); }else if(this.height > height){ Log.v(TAG, "Scrolled down"); } } return false; } }); 

Mi solución funciona perfectamente dando el valor exacto para cada dirección de desplazamiento. distanceFromFirstCellToTop contiene la distancia exacta entre la primera celda y la parte superior de la vista principal. Guardo este valor en previousDistanceFromFirstCellToTop y cuando me desplazo lo comparo con el nuevo valor. Si es más bajo entonces me deslicé hacia arriba, de lo contrario, me deslicé hacia abajo.

 private int previousDistanceFromFirstCellToTop; listview.setOnScrollListener(new OnScrollListener() { @Override public void onScrollStateChanged(AbsListView view, int scrollState) { } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { View firstCell = listview.getChildAt(0); int distanceFromFirstCellToTop = listview.getFirstVisiblePosition() * firstCell.getHeight() - firstCell.getTop(); if(distanceFromFirstCellToTop < previousDistanceFromFirstCellToTop) { //Scroll Up } else if(distanceFromFirstCellToTop > previousDistanceFromFirstCellToTop) { //Scroll Down } previousDistanceFromFirstCellToTop = distanceFromFirstCellToTop; } }); 

Para los desarrolladores de Xamarin, la solución es la siguiente:

Nota: no te olvides de ejecutar en el hilo de la interfaz de usuario

 listView.Scroll += (o, e) => { View firstCell = listView.GetChildAt(0); int distanceFromFirstCellToTop = listView.FirstVisiblePosition * firstCell.Height - firstCell.Top; if (distanceFromFirstCellToTop < previousDistanceFromFirstCellToTop) { //Scroll Up } else if (distanceFromFirstCellToTop > previousDistanceFromFirstCellToTop) { //Scroll Down } previousDistanceFromFirstCellToTop = distanceFromFirstCellToTop; }; 

He utilizado esta solución mucho más simple:

 setOnScrollListener( new OnScrollListener() { private int mInitialScroll = 0; @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { int scrolledOffset = computeVerticalScrollOffset(); boolean scrollUp = scrolledOffset > mInitialScroll; mInitialScroll = scrolledOffset; } @Override public void onScrollStateChanged(AbsListView view, int scrollState) { } } 

Sólo tienes que ajustar scroll listener a tu listview.

Si tiene un encabezado o un pie de página también debe comprobar el recuento visible. Si aumenta, significa que está desplazándose hacia abajo. (Invertir si hay un pie de página en lugar de encabezado)

Si no tiene ningún encabezado o pie de página en su listview puede quitar las líneas que cheks el elemento visible cuenta.

 listView.setOnScrollListener(new AbsListView.OnScrollListener() { public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if (mLastFirstVisibleItem > firstVisibleItem) { Log.e(getClass().toString(), "scrolling up"); } else if (mLastFirstVisibleItem < firstVisibleItem) { Log.e(getClass().toString(), "scrolling down"); } else if (mLastVisibleItemCount < visibleItemCount) { Log.e(getClass().toString(), "scrolling down"); } else if (mLastVisibleItemCount > visibleItemCount) { Log.e(getClass().toString(), "scrolling up"); } mLastFirstVisibleItem = firstVisibleItem; mLastVisibleItemCount = visibleItemCount; } public void onScrollStateChanged(AbsListView listView, int scrollState) { } }); 

Y tienen estas variables

 int mLastFirstVisibleItem; int mLastVisibleItemCount; 

Para detectar también el desplazamiento con elementos más grandes, prefiero un oyente onTouch:

 listview.setOnTouchListener(new View.OnTouchListener() { int scrollEventListSize = 5; float lastY; // Used to correct for occasions when user scrolls down(/up) but the onTouchListener detects it incorrectly. We will store detected up-/down-scrolls with -1/1 in this list and evaluate later which occured more often List<Integer> downScrolledEventsHappened; @Override public boolean onTouch(View v, MotionEvent event) { float diff = 0; if(event.getAction() == event.ACTION_DOWN){ lastY = event.getY(); downScrolledEventsHappened = new LinkedList<Integer>(); } else if(event.getAction() == event.ACTION_MOVE){ diff = event.getY() - lastY; lastY = event.getY(); if(diff>0) downScrolledEventsHappened.add(1); else downScrolledEventsHappened.add(-1); //List needs to be filled with some events, will happen very quickly if(downScrolledEventsHappened.size() == scrollEventListSize+1){ downScrolledEventsHappened.remove(0); int res=0; for(int i=0; i<downScrolledEventsHappened.size(); i++){ res+=downScrolledEventsHappened.get(i); } if (res > 0) Log.i("INFO", "Scrolled up"); else Log.i("INFO", "Scrolled down"); } } return false; // don't interrupt the event-chain } }); 

Almacene el primer objeto visible y en el siguiente cheque onScroll si el nuevo primer objeto visible es menor o mayor que el anterior.

Ejemplo pseudocódigo (no probado):

 int lastVisibleItem = 0; boolean isScrollingDown = false; void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if (firstVisibleItem > lastVisibleItem) { isScrollingDown = true; } else { isScrollingDown = false; } lastVisibleItem = firstVisibleItem; } 

Esos métodos no se pueden utilizar para detectar direcciones de desplazamiento directamente. Hay muchas maneras de conseguir la dirección. A continuación se explica un código simple (no comprobado) para uno de estos métodos:


 Public class ScrollTrackingListView extends ListView {

     Private boolean readyForMeasurement = false;
     Private Boolean isScrollable = null;
     Float privado prevDistanceToEnd = -1.0;
     Private ScrollDirectionListener listener = null;

     Public ScrollTrackingListView (Contexto contextual) {
         Super (contexto);
         en eso();
     }

     Public ScrollTrackingListView (Contexto contexto, AttributeSet attrs) {
         Super (contexto, attrs);
         en eso();
     }

     Public ScrollTrackingListView (Contexto contextual, AttributeSet attrs, int defStyle) {
         Super (contexto, attrs, defStyle);
         en eso();
     }

     Private void init () {
         ViewTreeObserver observador = getViewTreeObserver ();
         Observador.addOnGlobalLayoutListener (globalLayoutListener);
         SetOnScrollListener (scrollListener);
     }

     Private ViewTreeObserver.OnGlobalLayoutListener globalLayoutListener
             = New ViewTreeObserver.OnGlobalLayoutListener () {

         @Anular
         Public void onGlobalLayout () {
             ReadyForMeasurement = true;
             CalculateDistanceToEnd ();
         }

     };

     Public void registerScrollDirectionListener (Escucha de ScrollDirectionListener) {
         ScrollDirectionListener = escucha;
     }

     Public void unregisterScrollDirectionListener () {
         ScrollDirectionListener = null;
     }

     Private OnScrollListener scrollListener
             = New OnScrollListener () {

         @Anular
         Public void onScrollStateChanged (AbsListView absListView, int i) {
             CalculateDistanceToEnd ();
         }

         @Anular
         Public void onScroll (AbsListView absListView, int i, int i1, int i2) {
             // Hacer nada
         }

     };

     Private void calculateDistanceToEnd () {

         If (readyForMeasurement) {

             // Estoy usando la altura del diseño, barra de desplazamiento horizontal y
             // contenido junto con desplazamiento hacia abajo del offset

             // computeVerticalScrollExtent se utiliza para calcular la longitud del pulgar dentro de la pista de la barra de desplazamiento.
             // La longitud del pulgar es una función de la altura de la vista y la longitud del contenido.
             Int verticalScrollExtent = computeVerticalScrollExtent ();
             Int verticalScrollOffset = computeVerticalScrollOffset ();
             Int verticalScrollRange = computeVerticalScrollRange ();
             Int horizontalScrollBarHeight = getHorizontalScrollbarHeight ();

             Todos los derechos reservados
              * 1. Deje que "R" represente el rango de la barra de desplazamiento vertical.  Esto corresponde a la longitud del contenido
              * En la vista.
              * 2. Sea "E" la extensión de la barra de desplazamiento vertical.  La extensión es un valor constante y es
              * (Probablemente) igual a un valor proporcional a la altura de la vista.
              * 3. Desplazamiento "o" representa la posición actual en el rango visible para el usuario.  Puede tomar
              * Valores de "0 a E".
              *
              * Ahora el DistanceToEnd se calcula usando estos tres valores como sigue:
              *
              * DistanceToEnd = (R - o) / E
              *
              * DistanceToEnd mantendrá el valor en las unidades NumberOfScreenToEnd.
              *
              * /

             Float distanciaToEnd =
                     ((Float) (verticalScrollRange - verticalScrollOffset)) / ((float) (verticalScrollExtent));

             If (prevDistanceToEnd == -1) {
                  PrevDistanceToEnd = distanciaToEnd;
             } Else {
                  If (listener! = Null) {
                      If (distanceToEnd> prevDistanceToEnd) {
                         // El usuario se desplaza hacia arriba
                          Listener.onScrollingUp ();
                      } Else {
                         // El usuario se desplaza hacia arriba
                          Listener.onScrollingDown ();
                     }
                  }
                  PrevDistanceToEnd = distanciaToEnd;
             }

             If (isScrollable == null) {
                 // Compruebe si la altura de la vista es menor que una pantalla (es decir, no se habilita desplazamiento)
                 If ((horizontalScrollBarHeight + verticalScrollExtent)> = verticalScrollRange) {
                     IsScrollable = Boolean.FALSE;
                 } Else {
                     IsScrollable = Boolean.TRUE;
                 }
             }

         }

     }

     Interfaz pública ScrollDirectionListener {

         Public void onScrollingUp ();

         Public void onScrollingDown ();

     }

 }

La idea es calcular la distanciaToEnd. Si se aumenta distanceToEnd, el usuario se desplaza hacia arriba y si disminuye, el usuario se desplaza hacia abajo. Eso también le dará la distancia exacta al final de la lista.

Si sólo está tratando de saber si el usuario está desplazándose hacia arriba o hacia abajo puede anular el onInterceptTouchEvent para detectar la dirección de desplazamiento como a continuación:

     @Anular
     Public boolean onInterceptTouchEvent (evento MotionEvent) {
         Switch (event.getAction ()) {
             Case MotionEvent.ACTION_DOWN:
                 MInitialX = event.getX ();
                 MInitialY = event.getY ();
                 Devuelve verdadero;
             Case MotionEvent.ACTION_MOVE:
                 Flotador final x = evento.getX ();
                 Flotador final y = evento.getY ();
                 Flotador final yDiff = y - mInicial;  // yDiff menos de 0.0 implica desplazarse hacia abajo mientras que yDiff mayor que 0.0 implica desplazarse hacia arriba.  Si intento agregar los símbolos menores o mayores que los símbolos, la vista previa se niega a mostrarlo.
                 If (yDiff menos de 0.0) listener.onScrollingDown ();
                 Else if (yDiff mayor que 0.0) listener.onScrollingUp ();
                 descanso;
         }
         Return super.onInterceptTouchEvent (evento);
     }

Truco sobre la detección de desplazamiento hacia arriba o hacia abajo en listview, que acaba de llamar a esta función onScroll función en OnScrollListener de ListView.

 private int oldFirstVisibleItem = -1; private protected int oldTop = -1; // you can change this value (pixel) private static final int MAX_SCROLL_DIFF = 5; private void calculateListScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { if (firstVisibleItem == oldFirstVisibleItem) { int top = view.getChildAt(0).getTop(); // range between new top and old top must greater than MAX_SCROLL_DIFF if (top > oldTop && Math.abs(top - oldTop) > MAX_SCROLL_DIFF) { // scroll up } else if (top < oldTop && Math.abs(top - oldTop) > MAX_SCROLL_DIFF) { // scroll down } oldTop = top; } else { View child = view.getChildAt(0); if (child != null) { oldFirstVisibleItem = firstVisibleItem; oldTop = child.getTop(); } } } 

Manera simple de detectar el desplazamiento para arriba / abajo en android

 @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount){ if(prevVisibleItem != firstVisibleItem){ if(prevVisibleItem < firstVisibleItem) //ScrollDown else //ScrollUp prevVisibleItem = firstVisibleItem; } 

No olvides

 yourListView.setOnScrollListener(yourScrollListener); 

Por alguna razón el doc de Android no cubre esto, y el método utilizado no está ni siquiera en los documentos … me llevó un tiempo encontrarlo.

Para detectar si su pergamino está en la parte superior, usaría esto.

 public boolean checkAtTop() { if(listView.getChildCount() == 0) return true; return listView.getChildAt(0).getTop() == 0; } 

Esto verificará si su desplazador está en la parte superior. Ahora, para hacerlo por el fondo, tendrías que pasarle el número de hijos que tienes, y comprobar contra ese número. Es posible que tenga que averiguar cuántos están en la pantalla al mismo tiempo, y sustraer eso de su número de hijos. Nunca he tenido que hacer eso. Espero que esto ayude

Esto es lo que intentaría primero:

1) Crear una interfaz (llamémosla OnScrollTopOrBottomListener) con estos métodos:

Void onScrollTop ();

Void onScrollBottom ();

2) En el adaptador de tu lista, agrega una instancia de miembro, escribe como la interfaz que creaste y suministra un setter y getter.

3) En la implementación getView () de su adaptador, compruebe si el parámetro de posición es 0 o getCount () – 1. También compruebe que su instancia OnScrollTopOrBottomListener no es null.

4) Si la posición es 0, llame a onScrollTopOrBottomListener.onScrollTop (). Si la posición es getCount () – 1, llame a onScrollTopOrBottomListener.onScrollBottom ().

5) En su aplicación OnScrollTopOrBottomListener, llame a los métodos apropiados para obtener los datos deseados.

Espero que ayude de alguna manera.

-Brandon

He encontrado problemas usando algún ejemplo donde el tamaño de la célula de ListView es grande. Así que he encontrado una solución a mi problema que detecta el menor movimiento de su dedo. He simplificado al mínimo posible y es como sigue:

 private int oldScrolly; @Override public void onScrollStateChanged(AbsListView view, int scrollState) { } @Override public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) { View view = absListView.getChildAt(0); int scrolly = (view == null) ? 0 : -view.getTop() + absListView.getFirstVisiblePosition() * view.getHeight(); int margin = 10; Log.e(TAG, "Scroll y: " + scrolly + " - Item: " + firstVisibleItem); if (scrolly > oldScrolly + margin) { Log.d(TAG, "SCROLL_UP"); oldScrolly = scrolly; } else if (scrolly < oldScrolly - margin) { Log.d(TAG, "SCROLL_DOWN"); oldScrolly = scrolly; } } }); 

PD: Utilizo el MARGEN para no detectar el rollo hasta que alcances ese margen. Esto evita problemas cuando muestro u oculte vistas y evite parpadear.

  • ScrollBar en un listView ... personalizándolo.
  • Android: detecta si un ListView tiene la barra de desplazamiento (después de configurar nuevos datos)
  • Longitud androide de la barra de desplazamiento con diversos tamaños del artículo
  • Barra de desplazamiento personalizada de Android
  • ListView - barra de desplazamiento vertical en el lado izquierdo
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.