elenco album in Android

Question

Sto sviluppando un semplice lettore audio in Android. Voglio elencare l'album nel dispositivo.

Ho provato questo codice

String where = new String(); 
where = MediaStore.Audio.Media.IS_MUSIC + "=1"; 
private Cursor managedCursor; 
managedCursor = managedQuery(
     MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, 
     new String[] { 
      MediaStore.Audio.Media.TITLE, 
      MediaStore.Audio.Media._ID, 
      MediaStore.Audio.Media.ALBUM,  
      MediaStore.Audio.Media.ALBUM_ID,  
      MediaStore.Audio.Media.ARTIST, 
      MediaStore.Audio.Media.ARTIST_ID 
     }, 
     where,         
     null,          
     MediaStore.Audio.Media.DEFAULT_SORT_ORDER 
    ); 

    ListAdapter adapter = new AlbumListAdapter(
     this,         
     R.layout.albumlist_item,     
     managedCursor,       
     new String[] {       
      MediaStore.Audio.Media.ALBUM,  
      MediaStore.Audio.Media.ARTIST   
     }, 
     new int[] {        
      R.id.text_album, 
      R.id.text_artist 
     } 
    ); 
    setListAdapter(adapter); 

Ma questo codice sta elencando tutto il brano del nel dispositivo.

Qual è la struttura del database di Android Media Store.

Qualsiasi aiuto, per favore.

Answer 1

È opportuno interrogare gli album simili

String[] projection = new String[] { Albums._ID, Albums.ALBUM, Albums.ARTIST, Albums.ALBUM_ART, Albums.NUMBER_OF_SONGS }; 
String selection = null; 
String[] selectionArgs = null; 
String sortOrder = Media.ALBUM + " ASC"; 
Cursor cursor = contentResolver.query(Albums.EXTERNAL_CONTENT_URI, projection, selection, selectionArgs, sortOrder); 

http://developer.android.com/reference/android/provider/MediaStore.Audio.Albums.html

artisti, brani e generi tutto può essere interrogato in modo simile utilizzando il corretto EXTERNAL_CONTENT_URI e la proiezione corrispondente.

Speranza che aiuta ...

Answer 2

ho risolto gli album unici verificando se fossero già stati aggiunti alla mia mappa

public Map<String, String> getAlbumList(Context c) { 
    //setup map and cursor 
    Map<String, String> result = new HashMap<String, String>(); 
    String selection = MediaStore.Audio.Media.IS_MUSIC + " !=0"; 
    final Cursor mCursor = c.getContentResolver().query(
      MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, 
      new String[] {MediaStore.Audio.Media.ALBUM, 
        MediaStore.Audio.Media.ARTIST, 
        MediaStore.Audio.Media.ALBUM_ID,}, selection, null, 
        "LOWER ("+MediaStore.Audio.Media.ALBUM + ") ASC"); 

    int count = mCursor.getCount(); 


    String[] mArtist = new String[count]; 
    String[] mAlbum = new String[count]; 
    String[] AlbumID = new String[count]; 

    int i = 0; 
    int j = 0; 
    if (mCursor.moveToFirst()) { 

     do { 
      mAlbum[i] = mCursor 
        .getString(mCursor 
          .getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM)); 
      mArtist[i] = mCursor.getString(mCursor 
        .getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST)); 

      AlbumID[i] = Long.toString(mCursor 
        .getLong(mCursor 
          .getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM_ID))); 

            //checking for same previous value 
      if(result.containsValue(mAlbum[i])){ 

      }else{ 
      result.put("artist" + j, mArtist[i]); 
      result.put("album" + j, mAlbum[i]); 
      result.put("AlbumID" + j, AlbumID[i]); 
      j = j + 1; 
      } 
      i = i + 1; 

     } while (mCursor.moveToNext()); 
    } 

    result.put("count", Integer.toString(j)); 
    mCursor.close(); 
    return result; 
} 
} 

forse non

la soluzione più bella al dell'ordinamento univoco degli album .. ma funziona esattamente come previsto senza armeggiare con sqlite ....

sto passando in un contesto qui perché sto usando un listview in un frammento con un adattatore personalizzato senza il contesto di attività getContentResolver() doesn lavorare ...

Answer 3

uso di questo codice semplificato per ottenere l'elenco degli album

public ArrayList<AlbumModel> getListOfAlbums(Context context) { 

      String where = null; 

      final Uri uri = MediaStore.Audio.Albums.EXTERNAL_CONTENT_URI; 
      final String _id = MediaStore.Audio.Albums._ID; 
      final String album_name = MediaStore.Audio.Albums.ALBUM; 
      final String artist = MediaStore.Audio.Albums.ARTIST; 
      final String albumart = MediaStore.Audio.Albums.ALBUM_ART; 
      final String tracks = MediaStore.Audio.Albums.NUMBER_OF_SONGS; 

      final String[] columns = { _id, album_name, artist, albumart, tracks }; 
      Cursor cursor = context.getContentResolver().query(uri, columns, where, 
        null, null); 

      ArrayList<AlbumModel> list = new ArrayList<AlbumModel>(); 

      // add playlsit to list 

      if (cursor.moveToFirst()) { 

       do { 

        AlbumModel albumData = new AlbumModel(); 

        albumData 
          .setAlbumID(cursor.getLong(cursor.getColumnIndex(_id))); 

        albumData.setAlbumName(cursor.getString(cursor 
          .getColumnIndex(album_name))); 

        albumData.setALbumArtist(cursor.getString(cursor 
          .getColumnIndex(artist))); 

        albumData.setAlbumArt(cursor.getString(cursor 
          .getColumnIndex(albumart))); 

        albumData.setTracks(cursor.getString(cursor 
          .getColumnIndex(tracks))); 

        list.add(albumData); 

       } while (cursor.moveToNext()); 
      } 

      cursor.close(); 

      return list; 
     } 

Answer 4

public class Album { 

private long id; 
private String albumName; 
private String artistName; 
private int nr_of_songs; 
private Bitmap albumImg; 

public Album(long id, String albumName, String artistName, Bitmap albumImg, int nr_of_songs) { 
    this.albumImg = albumImg; 
    this.id = id; 
    this.albumName = albumName; 
    this.artistName = artistName; 
    this.nr_of_songs = nr_of_songs; 
} 

public void setId(long id) { 
    this.id = id; 
} 
public void setAlbumName(String albumName) { 
    this.albumName = albumName; 
} 
public void setArtistName(String artistName) { 
    this.artistName = artistName; 
} 
public void setAlbumImg(Bitmap albumImg) { 
    this.albumImg = albumImg; 
} 
public void setNr_of_songs(int nr_of_songs) { 
    this.nr_of_songs = nr_of_songs; 
} 

public long getID(){ 
    return id; 
} 
public String getAlbumName(){ 
    return albumName; 
} 
public String getArtistName() { 
    return artistName; 
} 
public Bitmap getAlbumImg() { 
    return albumImg; 
} 
public int getNr_of_songs() { 
    return nr_of_songs; 
} 

} 


public void getAlbumsLists(){ 
    String where = null; 

    final Uri uri = MediaStore.Audio.Albums.EXTERNAL_CONTENT_URI; 
    final String _id = MediaStore.Audio.Albums._ID; 
    final String album_name = MediaStore.Audio.Albums.ALBUM; 
    final String artist = MediaStore.Audio.Albums.ARTIST; 
    final String albumart = MediaStore.Audio.Albums.ALBUM_ART; 
    final String tracks = MediaStore.Audio.Albums.NUMBER_OF_SONGS; 

    final String[] columns = { _id, album_name, artist, albumart, tracks }; 
    Cursor cursor = context.getContentResolver().query(uri, columns, where, null, null); 

    if(cursor!=null && cursor.moveToFirst()){ 

     do { 

      long id = cursor.getLong(cursor.getColumnIndex(_id)); 
      String name = cursor.getString(cursor.getColumnIndex(album_name)); 
      String artist2 = cursor.getString(cursor.getColumnIndex(artist)); 
      String artPath = cursor.getString(cursor.getColumnIndex(albumart)); 
      Bitmap art = BitmapFactory.decodeFile(artPath); 
      int nr =Integer.parseInt(cursor.getString(cursor.getColumnIndex(tracks))); 

      albumList.add(new Album(id, name, artist2, art, nr)); 

     } while (cursor.moveToNext()); 
    } 

    cursor.close(); 
}