Adding Background Music to Android App

ruchira biyani, 23 Sep 2011

This article explains how to add background music while developing Android Apps, e.g., Games

Introduction
A large chunk of Android's application development consists of Game development. Background Music is an
integral part of a Game app. This article explains how to add music to any Android App using Media Player
provided by Android SDK Library. Familiarity with Android activity and services is assumed here.

Background
MediaPlayer class controls the playback of audio/video files and streams.
Its Life Cycle is implemented in the form of State Machine Diagram.The official Android development page
gives a nice explanation of its Life Cycle. I would recommend that you get familiar with the life cycle of
Media Player by going through it. The Media Player should be in prepared state to play the Music. In general,
the media sources can be: Local resources, Internal URIs, such as one you might obtain from a Content
Resolver, External URLs (streaming).
Our interest is in using local resources. So save your application's music fie in /res/raw directory.The various
supported music audio files are as follows:
MP3, MIDI, WAV, MP4, MP4A, 3GP, FLAC, ADTS Raw AAC (.aac decode only).

Use a Service with MediaPlayer

In order for media to be played in the background of your app location when the user is interacting with it
you must start a Service from your application's main activity and the service shall
contain all the methods related to playback. To allow activity to interact with the service, a service

connection is also required. In short, we need to implement a bounded service.

Generally speaking, playback control operation may fail due to various reasons, such as:

unsupported audio/video format,

poorly interleaved audio/video,
resolution too high,
streaming timeout,
programming error,
etc.

So include sufficient error handling and recovery mechanism. Under all these error conditions, the internal
player engine invokes a user supplied OnErrorListener.onError() method if an OnErrorListener has been
registered beforehand via setOnErrorListener(android.media.MediaPlayer.OnErrorListener) . The Media
player enters in "Error" state even if no error listener has been registered.So for error handling mechanism for
a media player, a good understanding of the state diagram of Media Player is a must.

Using the Code

Below is the code for a basic service implementing the media player.The code is written in JAVA by using
Android SDK on Eclipse IDE. Copy this code as a separate Java file named MusicService.class in your
Android application under src directory.The sample music which I played in my app is also available as
download as "jingle.mp3" and should be stored in "res/raw" directory.
As this is a bound service which allows other application components to bind and interact with it, we must
implement onbind() callback method. More details about the bound service is beyond the scope of this
document as it primarily deals with implementation of the Media Player and a good understanding of service is
assumed here.
Following are the important terms and functions implemented here and the rest are self explanatory:
The service implements onErrorListener for error handling and recovery
mBinder: An Ibinder object which shall be used by clients to interact with service
The Constructor is empty as I am only demonstrating the background music functionality here. But
depending on your application, you can perform some initialization here.
4.
Class ServiceBinder: As this service is private to the application and runs in the same process as the
client, you should create your interface by extending the Binder class and returning an instance of it
fromonBind(). The client receives the Binder and can use it to directly access public methods available in
either the Binder implementation or even the Service.
5.
OnCreate(): Here we create the Media player by calling mPlayer.create() and giving the path of the
music file as the argument. When create is called, the media player is already in prepared state so no need to
explicitly prepare the player.
Moreover since the music has to be played non-stop, it is made to loop and setvolume is used to set the initial
volume. Also the errorlistener is registered and onError() function is called when there is an error. You can
write your error handling code here. In my code, on error it is stopping the player and releasing the object.
6.
OnStartCommand: Player is started here and we return START_STICKY as the music has to be
played continuously throughout the app, unless paused or stopped by user.
1.
2.
3.

The remaining functions are simple and self explanatory.

Collapse | Copy Code

import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnErrorListener;
import android.os.Binder;
import android.os.IBinder;
import android.widget.Toast;
public class MusicService extends Service implements MediaPlayer.OnErrorListener{
private final IBinder mBinder = new ServiceBinder();
MediaPlayer mPlayer;
private int length = 0;
public MusicService() { }
public class ServiceBinder extends Binder {
MusicService getService()

{
return MusicService.this;
}
}
@Override
public IBinder onBind(Intent arg0){return mBinder;}
@Override
public void onCreate (){
super.onCreate();
mPlayer = MediaPlayer.create(this, R.raw.jingle);
mPlayer.setOnErrorListener(this);
if(mPlayer!= null)
{
mPlayer.setLooping(true);
mPlayer.setVolume(100,100);
}
mPlayer.setOnErrorListener(new OnErrorListener() {
public boolean onError(MediaPlayer mp, int what, int
extra){
onError(mPlayer, what, extra);
return true;
}
});
}
@Override
public int onStartCommand (Intent intent, int flags, int startId)
{
mPlayer.start();
return START_STICKY;
}
public void pauseMusic()
{
if(mPlayer.isPlaying())
{
mPlayer.pause();
length=mPlayer.getCurrentPosition();
}
}
public void resumeMusic()
{
if(mPlayer.isPlaying()==false)
{
mPlayer.seekTo(length);
mPlayer.start();
}
}
public void stopMusic()
{

mPlayer.stop();
mPlayer.release();
mPlayer = null;
}
@Override
public void onDestroy ()
{
super.onDestroy();
if(mPlayer != null)
{
try{
mPlayer.stop();
mPlayer.release();
}finally {
mPlayer = null;
}
}
}
public boolean onError(MediaPlayer mp, int what, int extra) {
Toast.makeText(this, "music player failed", Toast.LENGTH_SHORT).show();
if(mPlayer != null)
{
try{
mPlayer.stop();
mPlayer.release();
}finally {
mPlayer = null;
}
}
return false;
}

Binding the Activity to the Service

In your application's activity class (Java file), make the service connection by using the following code:
Collapse | Copy Code

private boolean mIsBound = false;

private MusicService mServ;
private ServiceConnection Scon =new ServiceConnection(){
public void onServiceConnected(ComponentName name, IBinder
service) {
mServ = ((MusicService.ServiceBinder)service).getService();
}
public void onServiceDisconnected(ComponentName name) {
mServ = null;
}
};
void doBindService(){
bindService(new Intent(this,MusicService.class),
Scon,Context.BIND_AUTO_CREATE);

mIsBound = true;
}
void doUnbindService()
{
if(mIsBound)
{
unbindService(Scon);
mIsBound = false;
}
}

In the above code, I have created a service connection Scon which gets the service to be called
in mServ variable in OnServiceConnected() and sets it to null once the service is
disconnected. doBindService anddoUnbindService are for binding and unbinding to the service respectively.
There is a boolean flag mIsBoundwhich gets set when the service is bound to activity.

Starting, Pausing, Resuming and Stopping the

Music
Follow the given steps:
Step 1: First bind the service to the activity by calling doBindService on your activity's onCreate as passing
an intent to the service.
Step 2: Start the service by an explicit Intent:
Collapse | Copy Code

Intent music = new Intent();

music.setClass(this,MusicService.class);
startService(music);

Step 3: From your activity, wherever you want to pause, resume or stop music, call the corresponding service
functions as follows:
Collapse | Copy Code

mServ.pauseMusic();
mServ.resumeMusic();
mServ.stopMusic();

Step 4: Don't forget to call

doUnbindService and
stopService(new Intent(MainActivity.this, MusicService.class))
from places where you want to unbind the service from the activity and stop the service. An ideal place is the
call to activity's onDestroy()method.

Step 5: In your application's androidmanifest file, paste the following XML code:
Collapse | Copy Code

"service android:name="MusicService"android:enabled="true"

History

19th September, 2011: Initial version

22nd September, 2011: Added Step 5