How to play a sound in Android Studio?

Android provides several APIs for playing audio in apps, including SoundPool for short sound effects and music, MediaPlayer for audio files and streams, and more advanced options like OpenSL ES and AAudio for low latency audio.

Adding sound effects or background music can greatly enhance the user experience in games, media apps, and other interactive apps. In this guide, we’ll focus on the basics of loading and playing short audio clips with SoundPool, one of the simpler audio options on Android.

Prerequisites

To play sounds in Android, you’ll need to have Android Studio installed on your development machine. Android Studio is the official integrated development environment (IDE) for Android app development, created by Google. It can be downloaded for free from the official Android Developer website.

The minimum system requirements for installing Android Studio are:

64-bit version of Windows, macOS, or Linux
8 GB RAM minimum (16 GB recommended)

2nd generation Intel Core or newer CPU (or compatible AMD CPU)

Once installed, Android Studio contains everything you need to start building Android apps including the Android SDK tools, emulators, and integration with Gradle builds. Having Android Studio set up on your machine is a prerequisite before you can start programming with Android audio APIs.

Add Media Resources

The first step is to add your sound files to the /res/raw folder in your Android project. This stores the audio files as resources that can be loaded by the app. To add a sound file:

In Android Studio, right-click on the res folder and select New > Directory.
Name the directory raw.
Copy your sound files (.mp3, .wav, etc.) into this raw directory.

For example, copy a file called beep.mp3 into /res/raw/. Now this sound can be loaded as a resource called R.raw.beep. You can add multiple sound files this way.[1]

The raw folder stores files in their raw binary format. This preserves audio fidelity compared to compressed formats like .png or .jpg. Storing sounds as resources also makes it easy to access them in code.[2]

Initialize AudioManager

To initialize AudioManager in Android Studio, we first need to get an instance of the AudioManager system service. This is done by calling getSystemService() and passing in Context.AUDIO_SERVICE as the parameter.

For example:


AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

We need to cast the return value to AudioManager since getSystemService() returns an Object. The AudioManager instance allows us to control different audio operations like adjusting volume, playing sounds and more.

According to the Android documentation, the AudioManager class should only be accessed from the application’s main thread. We cannot instantiate it directly using the new operator because AudioManager requires a Context object which connects it to the current application environment ¹.

So obtaining an instance via getSystemService() is the correct way to get access to AudioManager and its audio control APIs.

Load Sound with SoundPool

The SoundPool class is used to load and play audio samples in Android. To load a sound, first create a SoundPool object:


SoundPool soundPool = new SoundPool(MAX_STREAMS, AudioManager.STREAM_MUSIC, 0);

The constructor takes the maximum number of simultaneous streams, the audio stream type, and a quality parameter as arguments.

Then load the audio sample using the load() method, passing in the resource ID and priority:


int soundId = soundPool.load(context, R.raw.mysound, 1);

This loads mysound.wav from the raw resource folder and returns a sound ID. The priority 1 means it will be uncompressed. Higher priority sounds are loaded and played first.

The sound can then be played using this sound ID.

The SoundPool handles all the work of decoding the audio into a raw 16-bit PCM sample that can be played efficiently on Android devices. It’s recommended over MediaPlayer for short sound effects and loops.

For more details, see the SoundPool documentation: https://developer.android.com/reference/android/media/SoundPool

Play Sound

To play a sound loaded into the SoundPool, call the play() method on the SoundPool object. The play() method takes the sound ID of the sound you want to play, along with left and right volume values from 0.0 to 1.0. For example:

soundPool.play(soundID, leftVolume, rightVolume, priority, noLoop, rate);

Where:

soundID is the ID returned when loading the sound via load()

leftVolume and rightVolume are the volume levels for stereo playback
priority sets the priority of the sound, use 1 for high priority
noLoop specifies whether to loop or not

rate adjusts the playback speed

To play the sound at full volume:

soundPool.play(soundID, 1.0f, 1.0f, 1, 0, 1.0f);

This will start playing the sound loaded with the given soundID at full left and right volume, high priority, no looping, and normal playback rate.

You can load and play multiple sounds by calling load() and play() multiple times with different sound IDs.

Pause and Resume

To pause a sound that is currently playing, call the pause() method on the SoundPool instance, passing in the stream ID of the sound you want to pause:

soundPool.pause(streamId);

This will pause the playback of the sound mid-stream. To resume playback from where it left off, call the resume() method, again passing in the stream ID:

soundPool.resume(streamId);

So you can pause and resume sounds as needed in your app. Just make sure to keep track of the stream IDs for each sound as you will need to pass those to the pause() and resume() methods.

For more details, see the SoundPool.pause() and SoundPool.resume() documentation.

Stop Sound

To stop a sound that is currently playing in SoundPool, you need to call the stop() method and pass it the streamID of the sound you want to stop. The streamID is returned when you initially call play() on the SoundPool. Here is an example:

int streamId = soundPool.play(soundId, 1, 1, 0, 0, 1);


// ...
soundPool.stop(streamId);

As explained on Stack Overflow, the stop() method requires the stream ID rather than the sound ID, since it needs to know which specific playback instance to stop. The sound ID merely identifies the loaded sound you want to play, but there could be multiple streams created from playing that sound simultaneously, so stop() needs the exact stream ID in order to halt playback properly.

According to the Android Developer Reference for SoundPool, calling stop() is required to halt sounds that loop forever, since they will keep playing continuously otherwise.

Release Resources

Once you are done playing all sounds, it is important to properly release the resources used by the SoundPool. According to the Android developer documentation, SoundPool holds native resources like audio samples and streams. We need to manually release these resources when they are no longer needed.

To release the SoundPool resources, call the release() method on the SoundPool instance:

soundPool.release();

As noted in the Stack Overflow post, it is important to release SoundPool after all sounds have completed playing. Releasing too early can cause sounds to be cut off prematurely.

According to the Android documentation, after calling release() you should set the SoundPool reference to null to ensure it cannot accidentally be reused.

Conclusion

In summary, playing sounds in Android Studio involves adding media resources, initializing an AudioManager, loading sounds with SoundPool, calling play() to play them, pause() and resume() to control playback, stop() to end playback, and releasing resources when done. The AudioAttributes define how sounds are handled by the audio system. With the SoundPool class, short sound effects can be loaded from resources and played back easily.

For more information, refer to the official Android documentation on audio attributes and the SoundPool class. Additionally, there are tutorials and examples online that demonstrate sound playback code in detail. By following the best practices covered here, you can reliably play sound effects and audio in your Android app.