How to record audio in Android code?

ByJael Lawler

Audio recording is a common feature on Android devices that allows users to capture audio content such as voice memos, music, interviews, and more. With the Android SDK, developers can also programmatically access the microphone and record audio from within their own apps. There are several main use cases for audio recording on Android:

Recording voice memos – The built-in Sound Recorder app allows quick and easy voice recording. Apps like Google Voice also facilitate voice note taking.

Recording music – With audio apps like BandLab, musicians can record songs, podcasts, and other audio straight from an Android device.

Interviews and meetings – Journalists, students, and others can use audio recording apps to capture interviews, lectures, and discussions.

Adding audio to videos – Recording audio separately from video gives more flexibility in editing and post-processing.

Accessibility features – Voice recording assists users with disabilities by providing an alternative input method.

In this article, we’ll cover the key aspects of recording audio programmatically in an Android application. This includes initializing the audio recorder, starting and stopping recording, reading audio data, processing and saving the audio, and playing back recordings.

Prerequisites

To record audio in an Android app, there are a few prerequisites that need to be met:

Target Android API level 21 or higher – This provides access to the android.media.AudioRecord class which is needed for audio recording. Older API levels have more limited audio recording capabilities (source: https://developer.android.com/reference/android/media/AudioRecord).

Request RECORD_AUDIO permission – In order for the app to access the microphone and record audio, the RECORD_AUDIO permission must be requested in the Android manifest. If the permission is not granted, the app will not be able to record audio (source: https://developer.android.com/reference/android/Manifest.permission#RECORD_AUDIO).

Microphone hardware support – The Android device must have a microphone to capture audio input. Most modern Android phones come equipped with microphones, but it’s important to test audio recording functionality on a range of actual devices (source: https://www.verizon.com/articles/cell-phone-tips/how-to-record-audio-on-your-smartphone/).

Setup Audio Recorder

Before we can start recording audio, we need to initialize and configure an AudioRecord object. According to the Android developer documentation, AudioRecord is used for reading audio data from the audio hardware for recording into a byte array. We need to initialize it by specifying parameters like sample rate, channel configuration, audio encoding and buffer size.

Some key steps for initializing AudioRecord correctly:

  • Use a sample rate of 44100 Hz, which provides good audio quality.
  • Set channel configuration to CHANNEL_IN_STEREO for stereo recording.
  • Use ENCODING_PCM_16BIT for 16-bit pulse code modulation encoding.
  • Calculate the minimum buffer size required using AudioRecord.getMinBufferSize().
  • Pass the buffer size, sample rate, channel config and audio format to the AudioRecord constructor.

This will properly initialize the AudioRecord object with optimal audio recording settings as per the recommendations.

Start Recording

To start recording audio, you need to call the startRecording() method on the AudioRecord object you initialized earlier. This method takes no parameters and returns void. Here’s an example:


audioRecorder.startRecording();

Calling this method will begin capturing audio from the audio source and start writing the raw audio data to the internal buffer you specified when creating the AudioRecord instance. The audio data will continue to be captured until you call the stop() method.

According to the Descript article, you should call startRecording() after initializing the AudioRecord instance and setting any parameters, but before trying to read or process any of the audio data.

Once startRecording() is called, the AudioRecord object will continuously monitor the audio source and store new audio data as it becomes available. Your app just needs to read and process the data at the desired intervals.

Read Audio Data

To read audio data during recording in Android, you need to use callbacks and buffers with the AudioRecord class. When starting recording, you pass an AudioRecord.OnRecordPositionUpdateListener callback that will be triggered as audio data is captured. In the callback, you can access the audio data buffer which contains the most recent raw audio bytes recorded.

As noted in the Medium article Record, Replay and Visualize Raw Audio Data in Android, you first initialize an AudioRecord instance with the desired sample rate, channel config, audio format, and buffer size. Then in the onMarkerReached() callback method, you can call getBuffer() on the AudioRecord instance to get the most recent chunk of audio data. This buffer can be processed, visualized, or saved during recording as needed. The callback provides real-time access to the raw bytes being captured by the audio input hardware.

Properly configuring the AudioRecord object and implementing the recording callback allows efficient streaming and processing of audio data during recording, as detailed in the StackOverflow post Getting recent Bytes while recording Audio Android. The callback and buffer approach gives more control compared to MediaRecorder which handles compression and output formatting automatically.

Stop Recording

Once you are finished recording audio, you need to properly stop the recording and release the recorder resources. To stop recording, simply call the stop() method on the MediaRecorder instance:


mediaRecorder.stop();

This will stop the recording session. It is important to call stop() when you are done, otherwise the recording will continue indefinitely.

In addition to stopping, you also need to release the MediaRecorder resources by calling release():


mediaRecorder.release();

Releasing the resources is important to free up memory and avoid resource leaks in your app. Be sure to call both stop() and release() when finished with a recording.

Process Raw Audio Data

Once you have stopped recording, you will have raw audio data that needs to be processed and converted into a standard audio file format like WAV or MP3 before it can be played back or saved. There are a couple key aspects to processing the raw audio data:

Converting the raw data to WAV format – The AudioRecord API returns PCM data in a byte array. To convert this to a standard WAV file, you need to add WAV headers to the start of the byte array. The WavFile class in this Stack Overflow post shows how to generate the headers.

Choosing an encoding – The most common PCM encodings are 8 bit or 16 bit, and a sample rate like 44100 Hz. The encoding will determine the quality and file size. As noted in the Medium article, 16 bit encoding provides better dynamic range than 8 bit.

After adding WAV headers and choosing the encoding, you can save the byte array to a .wav file. Then it will be in a standard format for playback or further processing.

Save Recorded Audio

After recording audio, the raw audio data needs to be written to a file for storage and later playback. There are a few key steps involved in saving the recorded audio to a file in Android:

First, we need to decide on a file format to save the audio in. Common options include WAV, MP3, M4A, OGG, etc. WAV and MP3 are compatible with most audio players and are convenient formats to work with in Android.

Next, we obtain an output file path to write the data to. This involves getting access to external or internal storage through the appropriate Android storage APIs like getExternalStorageDirectory(). We can then create a new file object with the desired filename and path.

The audio data itself is stored in a byte array while recording. To save it, we can convert this byte array to an InputStream and write it to the output file path using standard Java file output streams like FileOutputStream. Useful utility methods like writeBytes() help handle chunked writing of the byte array.

Finally, we flush and close the output stream when done to ensure all audio data is written to disk. The saved file can then be retrieved from the storage location and played back as needed in the app.

Play Back Audio

To play back the recorded audio file in your Android app, you can use the MediaPlayer class. Here are the key steps:

First, initialize a new MediaPlayer instance and set the data source to your recorded audio file URI:

<MediaPlayer player = new MediaPlayer();
player.setDataSource(recordedAudioFileUri);>

Then call prepare() on the MediaPlayer instance to get it ready for playback:

<player.prepare();>

To start playback, call the start() method:

<player.start();>

The MediaPlayer will now begin playing back the audio file. To stop playback, call the stop() method:

<player.stop();>

Be sure to release the MediaPlayer resources when done by calling release():

<player.release();>

Using the MediaPlayer in this way allows you to easily play back audio files within your Android app, including recordings captured with the MediaRecorder.

Conclusion

In summary, we’ve covered the key steps for recording audio in Android code. We started by setting up the Audio Recorder, initializing it, and beginning recording. Then we discussed reading in the audio data, stopping the recording, processing the raw audio bytes, and saving the audio file. We also looked at how to play back the recorded audio.

To build on this foundation, you may want to explore more advanced audio processing techniques like adding effects, trimming the audio, or integrating speech recognition. The Android multimedia framework provides many additional APIs beyond the basic MediaRecorder that can help enhance your audio app. Check out the references below for more examples and documentation.

With the audio recording basics now understood, you have the tools to start building your own audio and voice apps on Android. Just remember to properly request permissions and optimize for audio quality. The rest is up to your imagination and creativity!

Additional resources:

https://developer.android.com/guide/topics/media/audio-capture

https://developer.android.com/reference/android/media/MediaRecorder

Leave a Reply

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