Crear fácil desplazamiento alfabético en ListView?

Question

Busco para emular la funcionalidad de la aplicación de música más reciente, a saber, el pequeño cursor que aparece, que le permite a uno para desplazarse súper rápido al artista/álbum/pista que están buscando:

¿Hay algún método para habilitar una funcionalidad como esta en un ListView en el SDK de Android?

Answer 1

Tener su adaptador lista implementar SectionIndexer. La aplicación de música también hace uso de AlphabetIndexer para hacer algo del trabajo pesado. También use setFastScrollEnabled(true) en el ListView real para habilitar esto.

Editar: Si no está utilizando un CursorAdapter, no podrá utilizar AlphabetIndexer. Es posible que intente buscar en la implementación here y ver lo difícil que sería para adaptarla a trabajar con un ArrayAdapter.

Answer 2

setFastScrollEnabled (true);

(http://developer.android.com/reference/android/widget/AbsListView.html)

Answer 3

En anddev.org me encontré con este tutorial: Alphabetic FastScroll ListView - similar to Contacts

También contiene una breve demo-video

espero que ayude!

Answer 4

para recoger los detalles acerca de los elementos que se muestran en una vista de lista, puede hacer esto:

@Override 
     public void onScroll(AbsListView view, int firstVisibleItem, 
       int visibleItemCount, int totalItemCount) { 

      albumButton.setText(songs.get(firstVisibleItem).getAlbum()); 

     } 

No es esto un poco más simple? Aquí, 'canciones' es una matriz de objetos Song. Incluso puede obtener el último elemento visible agregando firstVisibleItem + visibleItemCount. Encontré que esta técnica es muy útil. Entonces obtendrías la primera letra de cada canción. Supongo que el cuadro gris que contiene la letra en la aplicación de música que ha publicado es una especie de cuadro de diálogo.

De todos modos, espero que esto ayude. Soy consciente de que llego tarde, pero esto es para las personas futuras

Answer 5

Aquí está la subclase de ArrayAdapter que estoy usando. Tenga en cuenta que la objects que pase en que ya ha sido ordenados alfabéticamente, con Collections.sort(objects).

class SectionIndexingArrayAdapter<T> extends ArrayAdapter<T> implements 
     SectionIndexer { 

    HashMap<String, Integer> sectionsMap = new HashMap<String, Integer>(); 
    ArrayList<String> sectionsList = new ArrayList<String>(); 

    ArrayList<Integer> sectionForPosition = new ArrayList<Integer>(); 
    ArrayList<Integer> positionForSection = new ArrayList<Integer>(); 

    public SectionIndexingArrayAdapter(Context context, int textViewResourceId, 
      List<T> objects) { 
     super(context, textViewResourceId, objects); 

     // Note that List<T> objects has already been sorted alphabetically 
     // e.g. with Collections.sort(objects) **before** being passed to 
     // this constructor. 

     // Figure out what the sections should be (one section per unique 
     // initial letter, to accommodate letters that might be missing, 
     // or characters like ,) 
     for (int i = 0; i < objects.size(); i++) { 
      String objectString = objects.get(i).toString(); 
      if (objectString.length() > 0) { 
       String firstLetter = objectString.substring(0, 1).toUpperCase(); 
       if (!sectionsMap.containsKey(firstLetter)) { 
        sectionsMap.put(firstLetter, sectionsMap.size()); 
        sectionsList.add(firstLetter); 
       } 
      } 
     } 

     // Calculate the section for each position in the list. 
     for (int i = 0; i < objects.size(); i++) { 
      String objectString = objects.get(i).toString(); 
      if (objectString.length() > 0) { 
       String firstLetter = objectString.substring(0, 1).toUpperCase(); 
       if (sectionsMap.containsKey(firstLetter)) { 
        sectionForPosition.add(sectionsMap.get(firstLetter)); 
       } else 
        sectionForPosition.add(0); 
      } else 
       sectionForPosition.add(0); 
     } 

     // Calculate the first position where each section begins. 
     for (int i = 0; i < sectionsMap.size(); i++) 
      positionForSection.add(0); 
     for (int i = 0; i < sectionsMap.size(); i++) { 
      for (int j = 0; j < objects.size(); j++) { 
       Integer section = sectionForPosition.get(j); 
       if (section == i) { 
        positionForSection.set(i, j); 
        break; 
       } 
      } 
     } 
    } 

    // The interface methods. 

    public int getPositionForSection(int section) { 
     return positionForSection.get(section); 
    } 

    public int getSectionForPosition(int position) { 
     return sectionForPosition.get(position); 
    } 

    public Object[] getSections() { 
     return sectionsList.toArray(); 
    } 
} 

Answer 6

He encontrado una gran solución here ... funciona muy bien con una lista enorme ... agradable y rápido ... no hay tiempo de carga.

@Override 
public int getPositionForSection(int section) 
{ 
    log.info("Get position for section"); 

    for (int i = 0; i < this.getCount(); i++) 
    { 
     if (this.getItem(i).length() > 0) 
     { 
      String item = this.getItem(i).toUpperCase(); 
      if (item.charAt(0) == sections.charAt(section)) 
      { 
       return i; 
      } 
     } 
    } 
    return 0; 
} 

@Override 
public int getSectionForPosition(int arg0) 
{ 
    log.info("Get section"); 

    return 0; 
} 

@Override 
public Object[] getSections() 
{ 
    log.info("Get sections"); 

    String[] sectionsArr = new String[sections.length()]; 

    for (int i = 0; i < sections.length(); i++) 
    { 
     sectionsArr[i] = "" + sections.charAt(i); 
    } 
    return sectionsArr; 
}