Android Development Patterns: Best Practices for Professional Developers (2016)

---

To record audio, do the following:

1. Initialize the recorder.

2. Set the audio source via setAudioSource().

3. Set the output format via setOutputFormat().

4. Set the encoder to use via setAudioEncoder().

5. Set the file output via setOutputFile().

6. Ready the device to record via prepare().

7. Start the recording via start().

8. End the recording via stop().

9. Either reuse the object with reset() or release the object with release().

In practice, this would appear as follows in your application logic:

MediaRecorder mRecorder = new MediaRecorder();
// use the device microphone
mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
// replace OUTPUT_LOCATION with the proper filesystem path or variable
mRecoder.setOutputFile(OUTPUT_LOCATION);
try {
mRecoder.prepare();
} catch (IllegalStateException e) {
// handle the error here
} catch (IOException e) {
// handle the error here
}

try {
mRecorder.start();
} catch (IllegalStateException e) {
// handle the error here
}

try {
// use a button, timer, or other method to call the following:
mRecoder.stop();
} catch (IllegalStateException e) {
// handle the error here
}
// If you want to use the same MediaRecoder object use this
mRecorder.reset();
// If you want to discard the MediaRecoder object use this
mRecorder.release();
mRecoder = null;

Playing the recording back can be done via the MediaPlayer class. MediaPlayer can be used to play back not only audio files but also video files. MediaPlayer needs to be initialized and then pointed to the file to play; it then uses the prepare() and start() methods to begin playback.

The following two methods demonstrate how you can start and stop playback of audio files:

private void startPlayback() {
mPlayer = new MediaPlayer();
try {
// change FILETOPLAY to the path and file that you want to playback
mPlayer.setDataSource(FILETOPLAY);
// already in a try/catch block, no need to wrap prepare() in another
mPlayer.prepare();
mPlayer.start();
} catch (IllegalStateException e) {
// handle the error here
} catch (IOException e) {
// handle the error here
}
}

private void stopPlayback() {
mPlayer.release();
mPlayer = null;
}

Now that you understand how audio works with Android, let’s look at how video works.

Working with Video

Similar to how Android supports a wide variety of audio formats and codecs, it also supports a variety of video containers and codecs. Table 12.2 lists the supported video formats.

Table 12.2 Supported Video Codecs and Containers

Video Playback

Video files can be played back in a variety of different ways, including using the MediaPlayer class. However, there is a View that specifically exists for playing back video files.

Unlike audio files, video needs access to the screen. This means that you either need to use a VideoView or SurfaceView. Note that, depending on what your application does, you may find it easier to work with a VideoView.

When using a VideoView, note that if the Activity is moved into the background, the View will not retain state automatically. This means that you need to pause and save the playback state on pause and restore the video on resume of the Activity.

Adding a VideoView can be as simple as dragging and dropping it from the Design view of Android Studio into your layout. Alternatively, you can add the following XML to your layout XML file:

<VideoView
android:id="@+id/myVideoView"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_centerInParent="true" />

Now that you have the VideoView added to your layout, you will want to play a video in it. To work with a remote or streaming video, you need to create a URI for it. This can be done as follows:

// change the value to an actual video, this is only an example
String videoAddress = "https://video.website.com/video.mp4";
Uri videoURI = Uri.parse(videoAddress);

For applications that will be streaming video files, you need to add the INTERNET permission to your application manifest. As a reminder, this is done by adding the following permission to your application manifest XML:

<uses-permission android:name="android.permission.INTERNET" />

The video can then be programmatically attached to the VideoView by referencing the ViewView and using the setVideoURI() method. This is shown as follows:

VideoView myVideoView = (VideoView)findViewById(R.id.myVideoView);
myVideoView.setVideoURI(videoURI);

If you only wanted to play a video without user interaction, you could finish here by using the start() method on the VideoView object. However, if you want to add scrubbing and other controls, you can use the MediaController class with your VideoView. This is done by creating a MediaController object, anchoring it to the VideoView, and then setting the MediaController object to the VideoView, as follows:

MediaController myMediaController = new MediaController(this);
myMediaController.setAnchorView(myVideoView);
MyViewView.setMediaController(myMediaController);

If you want to use the MediaPlayer class rather than the VideoView, you will need to use a SurfaceView. The SurfaceView is a special view that is used as a canvas to be drawn on. Because video playback involves multiple frames being drawn, the SurfaceView is used as the screen to draw the frames on.

Adding a SurfaceView to your application is done in one of two ways: You can use the Design mode in Android Studio and then drag and drop the SurfaceView into your layout, or you can add the following code to your layout XML file:

<SurfaceView
android:id="@+id/mySurfaceView"
android:layout_width="match_parent"
android:layout_height="match_parent" />

In your Activity class, you need to implement SurfaceHolder.Callback and MediaPlayer.OnPreparedListener. The following shows a sample of how your main Activity might look:

public class MainActivity extends Activity
implements SurfaceHolder.Callback, OnPreparedListener {
// your activity code
}

When you add the required implementations, Android Studio should automatically generate some method stubs for you. If it doesn’t, add the following to your Activity:

@Override
public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
// TODO Auto-generated method stub
}

@Override
public void surfaceCreated(SurfaceHolder arg0) {
// MediaPlayer code will go in this method
}

@Override
public void surfaceDestroyed(SurfaceHolder arg0) {
// TODO Auto-generated method stub
}

@Override
public void onPrepared(MediaPlayer mp) {
// MediaPlayer start method should be called here
}

The next step is to create a few variables, set them, set up the MediaPlayer, and then start the player. The following shows an example of this:

// create variables
private MediaPlayer mPlayer;
private SufaceHolder mSurfaceHolder;
private SurfaceView mSurfaceView;
String videoAddress = "https://video.website.com/video.mp4";

// other code in your activity...

@Override
protected void onCreate(Bundle savedInstanceState) {
// onCreate code...
mSurfaceView = (SurfaceView) findViewById(R.id.mySurfaceView);
mSurfaceHolder = mSurfaceView.getHolder();
mSurfaceHolder.addCallback(this);
}

// other code in your activity...

@Override
public void surfaceCreated(SurfaceHolder arg0) {
// Remember to handle the setup of the MediaPlayer for the version
// of Android that you are targeting, make changes as needed
try {
mPlayer = new MediaPlayer();
mPlayer.setDisplay(mSurfaceHolder);
mPlayer.setDataSource(videoAddress);
mPlayer.prepare();
mPlayer.setOnPreparedListener(this);
mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
} catch (Exception e) {
// handle the exception
}
}

// other code in your activity...

@Override
public void onPrepared(MediaPlayer mp) {
mPlayer.start();
}

In the preceding example, note the comments to help you place the code in the proper location in your application. When working with MediaPlayer, remember to use the builder pattern when working with API 21+.

You should also consider using a service to prepare playback for video and audio files to keep any potential sluggishness and ANR errors from wrecking your application.

Summary

In this chapter, you learned that Android has wide support for many types of media files. You learned that audio files can be bundled in your application as sound effects. You learned that these files can be included in a compressed format to save device space and then be processed into memory for playback.

You learned that there is a limit to how many files can be played simultaneously and that files loaded into memory can be bundled into sound packs that can be loaded when needed and released when finished to clear out used system resources.

You also learned that Android has broad support for video containers and codecs. Some video files, such as VP9 and WebM, offer better compression and quality than other files but are only supported in newer versions of Android.

Lastly, you learned that video files can be played back with a VideoView. You were shown how to include a VideoView and then use it in conjunction with a MediaController to add controls such as a play/pause button as well as a scrubbing bar. You also learned that videos can leverage the MediaPlayer class and be played back on a SurfaceView, and you were shown the basic setup of doing this in an Activity.