I did it this way and I'm pleased with the result:

1st create the service:

public class LocalService extends Service
{
    // This is the object that receives interactions from clients. See RemoteService for a more complete example.
    private final IBinder mBinder = new LocalBinder();
    private MediaPlayer player;

    /**
     * Class for clients to access. Because we know this service always runs in
     * the same process as its clients, we don't need to deal with IPC.
     */
    public class LocalBinder extends Binder
    {
        LocalService getService()
        {
            return LocalService.this;
        }
    }

    @Override
    public void onCreate()
    {

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        // We want this service to continue running until it is explicitly stopped, so return sticky.
        return START_STICKY;
    }

    @Override
    public void onDestroy()
    {
        destroy();
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        return mBinder;
    }


    public void play(int res)
    {
        try
        {
            player = MediaPlayer.create(this, res);
            player.setLooping(true);
            player.setVolume(0.1f, 0.1f);
            player.start();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }


    public void pause()
    {
        if(null != player && player.isPlaying())
        {
            player.pause();
            player.seekTo(0);
        }
    }


    public void resume()
    {
        try
        {
            if(null != player && !player.isPlaying())
            {
                player.start();
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }


    public void destroy()
    {
        if(null != player)
        {
            if(player.isPlaying())
            {
                player.stop();
            }

            player.release();
            player = null;
        }
    }

}

2nd, create a base activity and extend all your activities in witch you wish to play the background music from it:

public class ActivityBase extends Activity
{
    private Context context = ActivityBase.this;
    private final int [] background_sound = { R.raw.azilum_2, R.raw.bg_sound_5 };
    private LocalService mBoundService;
    private boolean mIsBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        doBindService();
    }

    @Override
    protected void onStart()
    {
        super.onStart();

        try
        {
            if(null != mBoundService)
            {
                Random rand = new Random();
                int what = background_sound[rand.nextInt(background_sound.length)];
                mBoundService.play(what);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

    @Override
    protected void onStop()
    {
        super.onStop();
        basePause();
    }



    protected void baseResume()
    {
        try
        {
            if(null != mBoundService)
            {
                mBoundService.resume();
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }


    protected void basePause()
    {
        try
        {
            if(null != mBoundService)
            {
                mBoundService.pause();
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }



    private ServiceConnection mConnection = new ServiceConnection()
    {
        public void onServiceConnected(ComponentName className, IBinder service)
        {
            // This is called when the connection with the service has been
            // established, giving us the service object we can use to
            // interact with the service. Because we have bound to a explicit
            // service that we know is running in our own process, we can
            // cast its IBinder to a concrete class and directly access it.
            mBoundService = ((LocalService.LocalBinder) service).getService();

            if(null != mBoundService)
            {
                Random rand = new Random();
                int what = background_sound[rand.nextInt(background_sound.length)];
                mBoundService.play(what);
            }
        }

        public void onServiceDisconnected(ComponentName className)
        {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            // Because it is running in our same process, we should never
            // see this happen.
            mBoundService = null;

            if(null != mBoundService)
            {
                mBoundService.destroy();
            }
        }
    };

    private void doBindService()
    {
        // Establish a connection with the service. We use an explicit
        // class name because we want a specific service implementation that
        // we know will be running in our own process (and thus won't be
        // supporting component replacement by other applications).

        Intent i = new Intent(getApplicationContext(), LocalService.class);
        bindService(i, mConnection, Context.BIND_AUTO_CREATE);
        mIsBound = true;
    }

    private void doUnbindService()
    {
        if (mIsBound)
        {
            // Detach our existing connection.
            unbindService(mConnection);
            mIsBound = false;
        }
    }


    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        doUnbindService();
    }
}

And that's it, now you have background sound in all the activities that are extended from ActivityBase.

You can even control the pause / resume functionality by calling basePause() / baseResume().

Don't forget to declare the service in manifest:

<service android:name="com.gga.screaming.speech.LocalService" />

Read More

Keep the player in the background as a static reference. Then let it know if you are moving within the app or out of it. Here is how I would do it. I am using a class named DJ for this purpose.

public class DJ { 
private static MediaPlayer player;
private static boolean keepMusicOn;

public static void iAmIn(Context context){
if (player == null){
player = MediaPlayer.create(context, R.raw.music1);
player.setLooping(true);

try{
player.prepare();
}
catch (IllegalStateException e){}
catch (IOException e){}
}

if(!player.isPlaying()){
player.start();
}

keepMusicOn= false;
}

public static void keepMusicOn(){
keepMusicOn= true;
}

public static void iAmLeaving(){

if(!keepMusicOn){
player.pause();
}
}
}

Now from your Activity call the DJ like this.(Let him know if you would like to keep the music on)

public void onPause() {
super.onPause();
DJ.iAmLeaving();
}

public void onResume(){
super.onResume();
DJ.iAmIn(this); 
}

public void buttonOnClick(View view){
DJ.keepMusicOn();
Intent intent = new Intent(this, TheOtherActivity.class);
startActivity(intent);
}

Read More

use this

public void onPrepared(MediaPlayer mp) 
 {
   Log.i("StreamAudioDemo", "prepare finished");
   //pd.setMessage("Playing.....");

// mp.start(); - this should be removed 
   if(mp.isPlaying()== true)
   {
     mp.pause();

       iv.setImageResource(R.drawable.pause);
   }
   else 
   {
      mp.start();
       mp.release();
       iv.setImageResource(R.drawable.play);
   }

}

Read More

Try this-

final MediaPlayer mp1 = MediaPlayer.create(this, R.raw.one);
final MediaPlayer mp2 = MediaPlayer.create(this, R.raw.two);

Button btn = (Button)this.findViewById (R.id.button1);
btn.setOnClickListener(new OnClickListener(){
    @override
    public void onClick(View v) {
        mp1.start();
        mp2.pause();
        mp2.seekTo(0);
    }
});

Button btn1 = (Button)this.findViewById (R.id.button2);
btn1.setOnClickListener(new OnClickListener(){
    @Override
    public void onClick(View v) {
        mp1.pause();
        mp1.seekTo(0);
        mp2.start();
    }
});

Read More

ok I got the working code:-

public class SettingsActivity extends PreferenceActivity {

MediaPlayer mp;
SharedPreferences pref;
Preference p;
MyProfile myProfile;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
     pref = PreferenceManager.getDefaultSharedPreferences(this);
    getFragmentManager().beginTransaction().replace(android.R.id.content,
            new PrefsFragment()).commit();
          PreferenceManager.setDefaultValues(SettingsActivity.this, R.xml.settings, false);

}

@SuppressLint("ValidFragment")
public class PrefsFragment extends PreferenceFragment{

      @Override
      public void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);
       addPreferencesFromResource(R.xml.settings);
      }

      @Override
      public void onResume(){
       super.onResume();
       // Set up a listener whenever a key changes             
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(listener);

        for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); ++i) {
            Preference preference = getPreferenceScreen().getPreference(i);
            if (preference instanceof PreferenceGroup) {
              PreferenceGroup preferenceGroup = (PreferenceGroup) preference;
              for (int j = 0; j < preferenceGroup.getPreferenceCount(); ++j) {
                updatePrefSummary(preferenceGroup.getPreference(j));
              }
            } else {
              updatePrefSummary(preference);
            }
          }
      }

      @Override
      public void onPause() { 
       super.onPause();
       // Unregister the listener whenever a key changes   
      //  stopPlay();
     //     getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(listener);     
      } 

      public void onDestroy() {
          super.onDestroy();
           // Unregister the listener whenever a key changes 
         // stopPlay();
            getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(listener);
      };

      OnSharedPreferenceChangeListener listener = new OnSharedPreferenceChangeListener() {

        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
                String key) {
            // TODO Auto-generated method stub
             updatePrefSummary(findPreference(key));
             String ringTone = sharedPreferences.getString("prefRingtone", "0");
             int num = Integer.parseInt(ringTone);     
             if(mp!=null){
                 if(mp.isPlaying()){
                     mp.stop();
                 } 
                if(num == 0){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.airtel);
                }
                else if(num == 1){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.dance);
                }
                else if(num == 2){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.dhoom);
                }
                else{
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.guitar);
                }   
             }  
             else{
                 if(num == 0){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.airtel);
                }
                else if(num == 1){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.dance);
                }
                else if(num == 2){
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.dhoom);
                }
                else{
                    mp= MediaPlayer.create(getApplicationContext(), R.raw.guitar);
                }   
             }
            //    mp= MediaPlayer.create(getApplicationContext(), R.raw.airtel);
                mp.setLooping(true);
                Boolean onORoff = sharedPreferences.getBoolean("prefMusic", false); 
                if(onORoff){
                        mp.start();
                }
                else {
                        mp.pause();
                    //  mp.release();
                }
        }
        };

      private void updatePrefSummary(Preference p){

          if(p instanceof ListPreference){
              ListPreference listPref = (ListPreference) p; 
                p.setSummary(listPref.getEntry()); 
          }
          else{
              SwitchPreference swPref = (SwitchPreference)p;
              if(pref.getBoolean("prefMusic", true)){
                  swPref.setSwitchTextOn("ON");
                  p.setSummary(swPref.getSwitchTextOn());
              }
              else{
                  swPref.setSwitchTextOff("OFF");
                  p.setSummary(swPref.getSwitchTextOff());
              }
          }
      }

}
 }

Read More