How do I get all audio files from MediaStore?

ByJael Lawler

MediaStore is an API provided by the Android operating system to access media files on the device. It allows developers to query and retrieve audio, video, and image files stored locally on the phone or tablet. Developers may want to access audio files from MediaStore to create media player apps, audio editing apps, or any other app that requires access to music, podcasts, audiobooks and other audio files.

Some key benefits of using MediaStore to access audio files include:

  • Easy access to all audio files, regardless of their actual location on device storage
  • Ability to get metadata like artist, album, title for each audio file
  • No need to request runtime permissions since MediaStore requires no external storage permissions
  • Better performance and efficiency than scanning the raw filesystem

In summary, MediaStore provides a convenient unified interface for accessing audio files on Android. This guide will cover the basics of querying and retrieving audio files using MediaStore.

Get a Reference to MediaStore

To query the MediaStore content provider in Android, we first need to get a reference to it by calling Context.getContentResolver(). This returns a ContentResolver instance that we can use to interact with MediaStore.

For example:


ContentResolver resolver = context.getContentResolver();

The ContentResolver class provides read and write access to content providers like MediaStore. It handles all direct transactions with the content provider so we don’t have to worry about the underlying implementation.

According to the Android documentation, the ContentResolver object is bound to the application context we provide, so we need to use either the Activity or Application context to get access to the appropriate data.

Once we have a ContentResolver, we can use it to query MediaStore for audio files.

Query All Audio Files

To query all the audio files on the device, we need to use the ContentResolver.query() method to query the MediaStore audio content provider. The audio files are exposed via the MediaStore.Audio.Media content URI. Here is an example query to get audio file metadata:


Cursor cursor = getContentResolver().query(
    MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
    new String[]{ 
        MediaStore.Audio.Media._ID,
        MediaStore.Audio.Media.TITLE, 
        MediaStore.Audio.Media.ARTIST,
        MediaStore.Audio.Media.DURATION 
    }, 
    null,
    null,
    null
);

This query will return a Cursor with the ID, title, artist, and duration for all audio files. We specify the columns we want returned, like TITLE and ARTIST. To iterate through the results, use methods like moveToNext() on the Cursor.

To cite one of the sources you provided [1], we need access permissions to read media and the usage is demonstrated with querying the MediaStore content provider.

Use a Cursor to Iterate Results

The Cursor class in Android provides access to the rows returned from a database query. To iterate through the rows, you first need to move the cursor to the first row by calling moveToFirst():

Cursor cur = // query database
if (cur.moveToFirst()) {
  do {
    // get values from cur
  } while(cur.moveToNext());
}

This loops through each row in the cursor. Inside the loop, you can call methods like getString(), getInt() etc. to retrieve the column values for the current row. For example:

String title = cur.getString(cur.getColumnIndex(MediaStore.Audio.Media.TITLE));

gets the title field for each audio file.

So by iterating the cursor and retrieving column values, you can process each returned row from the audio query one by one.

Get Audio File Metadata

Once we have the cursor with the query results, we can iterate through each row and extract metadata about each audio file. Some key pieces of metadata we may want to retrieve include:

  • Title – The track title
  • Artist – The artist name
  • Album – The album name
  • Duration – The length of the track
  • Size – The file size
  • Path – The file system path of the audio file

We can get these metadata values from the cursor by calling methods like getString(), getInt(), etc. and passing in the column index we want. For example:

String title = cursor.getString(cursor.getColumnIndex(MediaStore.Audio.Media.TITLE));
String artist = cursor.getString(cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST)); 
int duration = cursor.getInt(cursor.getColumnIndex(MediaStore.Audio.Media.DURATION));

By retrieving this metadata for each audio file in our query results, we can then display it to the user in a UI, use it to sort/filter the list, save it along with the file path for later use, or whatever our application requires.

Retrieve the Actual Audio File

To actually retrieve the audio data from a content URI, you need to open a file descriptor to access the underlying file. This can be done with the ContentResolver.openFileDescriptor() method:

For example:


Uri audioUri = // URI from MediaStore query

ParcelFileDescriptor pfd = getContentResolver().openFileDescriptor(audioUri, "r");

FileInputStream fis = new FileInputStream(pfd.getFileDescriptor());

This gives you a FileInputStream that can read the audio data. You would typically pass this stream to an AudioTrack or media player to actually play the audio.

The key things to note are:

  • Use ContentResolver.openFileDescriptor() to get a ParcelFileDescriptor
  • Read audio data from the file descriptor

See the Android documentation for more details on handling content URIs.

Play the Audio Files

To play the audio files retrieved from the MediaStore, we can use the Android MediaPlayer class. The MediaPlayer provides capabilities for playing audio and video files. To play an audio file, follow these steps:

  1. Create a new MediaPlayer instance.
  2. Call setDataSource() method and pass the path to the audio file to set the data source.
  3. Call the prepare() method to prepare the media player.
  4. To start playback, call the start() method.
  5. To stop playback, call the stop() method.
  6. Call the release() method when done to free resources.

We can call these MediaPlayer methods in sequence for each audio file we retrieved from the MediaStore to play them back. The MediaPlayer handles playback in a background thread, so our UI will remain responsive.

For example:

MediaPlayer mediaPlayer = new MediaPlayer();
mediaPlayer.setDataSource(audioFilePath);

mediaPlayer.prepare();
mediaPlayer.start();
// play audio

mediaPlayer.stop();
mediaPlayer.release();

Filter the Query

The query to the ContentResolver can be filtered down to specific results by using the selection and selectionArgs parameters. For example, to limit the query to only return audio files by a certain artist:

String selection = MediaStore.Audio.Media.ARTIST + " = ?";
String[] selectionArgs = new String[] {"My Artist"};

Cursor cursor = getContentResolver().query(
    MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
    null, 
    selection,
    selectionArgs,
    null
);

The selection parameter allows specifying a SQL WHERE clause to filter results. The selectionArgs parameter binds values to the ? placeholders in the selection. This filters the query to only return audio files where the artist name matches “My Artist”.

Other common filters include album, genre, year, etc. See the MediaStore.Audio.Media reference for all supported columns that can be used to filter an audio query.

Order the Results

You can order the audio files returned from the MediaStore query using the ORDER BY clause in the SQL statement. This allows you to sort the results based on different metadata columns.

For example, to sort the audio files alphabetically by title:


Cursor cursor = context.getContentResolver().query(
MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
projection,
selection,
null,
MediaStore.Audio.Media.TITLE + " ASC");

You can also sort by the date added, artist, album, duration, etc. Some common sort orders:

  • Title: MediaStore.Audio.Media.TITLE + " ASC/DESC"
  • Artist: MediaStore.Audio.Media.ARTIST + " ASC/DESC"
  • Album: MediaStore.Audio.Media.ALBUM + " ASC/DESC"
  • Date added: MediaStore.Audio.Media.DATE_ADDED + " ASC/DESC"
  • Duration: MediaStore.Audio.Media.DURATION + " ASC/DESC"

The sort order allows you to organize the audio files in the order that makes the most sense for your app.

Conclusion

To summarize, getting all audio files from the MediaStore on Android involves first getting a reference to the
MediaStore, then querying for audio files specifically with parameters to filter and order the results. We iterate through the returned cursor to get the metadata for each audio file and can then use that to retrieve the actual audio file data to play back. Along the way we saw how to apply filters to narrow to particular audio files, order the results chronologically or alphabetically, and how to handle permissions for accessing the MediaStore.

To learn more about working with audio, images, and video on Android, check out the following additional resources:

Leave a Reply

Your email address will not be published. Required fields are marked *