如果你想播放背景音乐为您的应用程序而已，然后发挥它从你的应用程序/使用的AsyncTask类来为你做它启动一个线程。

服务的概念是在后台运行;通过背景，意义，通常是当你的应用程序用户界面是不可见。诚然，它可以用来就像你（如果你还记得停止它），但它只是不正确的，而且它消耗你不应该使用的资源。

如果你想peform任务对你的活动的背景下，使用AsyncTask的。

顺便说一句，ONSTART是pcated德$ P $。当你使用的服务，实现onStartCommand。

更新：

我觉得这$​​ C $ C会为你工作。添加这个类（在您的活动类附后）。

 公共类BackgroundSound扩展的AsyncTask＆LT;虚空，虚空，虚空＆GT; {
@覆盖
保护无效doInBackground（虚空...... PARAMS）{
    的MediaPlayer播放器= MediaPlayer.create（YourActivity.this，R.raw.test_cbr）;
    player.setLooping（真正的）; //设置循环
    player.setVolume（100,100）;
    player.start（）;
    返回null;
 }
   }
 

现在，为了控制音乐，保存annonymously创造它的你BackgroundSound对象来代替。声明它作为一个字段的活动：

  BackgroundSound mBackgroundSound =新BackgroundSound（）;
 

在您的活动的onResume方法，启动：

 公共无效onResume（）{
super.onResume（）;
mBackgroundSound.execute（空）;
}
 

和您的活动的的onPause方法，阻止它：

 公共无效的onPause（）{
super.onPause（）;
mBackgroundSound.cancel（真正的）;
}
 

这会工作。

I have My Activity Code like Below:

public class Player extends Activity implements OnCompletionListener,
OnPreparedListener, OnErrorListener, OnBufferingUpdateListener, MusicFocusable {

    private Boolean playState = false;  
    private String station = "http://38.101.19.5:9157";
    public static final float DUCK_VOLUME = 0.1f;
    private String artistName = null;
    private String trackName = null;

    private TextView artist;
    private TextView track;
    private TextView status;
    private Button play;

    enum AudioFocus {
        NoFocusNoDuck, // we don't have audio focus, and can't duck
        NoFocusCanDuck, // we don't have focus, but can play at a low volume
                        // ("ducking")
        Focused // we have full audio focus
    }

    private AudioFocus mAudioFocus = AudioFocus.NoFocusNoDuck;

    private MediaPlayer mPlayer = null;
    private AndroidShoutcastLib shoutcast;
    private AudioManager mAudioManager;
    AudioFocusHelper mAudioFocusHelper = null;

    Handler handler = new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_player);

        mAudioManager = (AudioManager) getSystemService(AUDIO_SERVICE);

        // create the Audio Focus Helper, if the Audio Focus feature is
        // available (SDK 8 or above)
        if (android.os.Build.VERSION.SDK_INT >= 8) {
            mAudioFocusHelper = new AudioFocusHelper(getApplicationContext(),
                    this);
        }
        else {
            mAudioFocus = AudioFocus.Focused; // no focus feature, so we always "have" audio focus
        }

        status = (TextView) findViewById(R.id.status);

        artist = (TextView) findViewById(R.id.artist);
        artist.setSelected(true);

        track = (TextView) findViewById(R.id.track);
        track.setSelected(true);

        play = (Button) findViewById(R.id.play);

        play.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View btn) {
                if (!playState) {
                    play.setText("Pause");
                    handler.postDelayed(handlePlayRequest, 300);
                }
                else {
                    play.setText("Play");
                    status.setText("Press Play");
                    handler.postDelayed(handlePlayRequest, 300);
                }
            }

        });

        shoutcast = new AndroidShoutcastLib();

        try {
            shoutcast.setShoutcastUrl(station);
        } catch (InvalidStreamURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        shoutcast.setOnMetadataChangedListener(new MetadataListener(){

            @Override
            public void OnMetadataChanged(Metadata item) {
                artistName = item.artist;
                trackName = item.track;             
                updateMeta();
            }
        });

        setVolumeControlStream(AudioManager.STREAM_MUSIC);      
    }

    public void onDestroy() {
        super.onDestroy();

        shoutcast = null;
        handler.removeCallbacks(handlePlayRequest);
    }

    public void updateMeta() {
        handler.post(new Runnable() {
            @Override
            public void run() {
                // This gets executed on the UI thread so it can safely modify Views
                artist.setText(artistName);
                track.setText(trackName);
            }
        });
    }

    private final Runnable handlePlayRequest = new Runnable() {
        public void run() {
            if (playState) {
                Log.d("Player", "Stop Called");
                giveUpAudioFocus();
                mPlayer.stop();
                mPlayer.reset();
                mPlayer.release();
                shoutcast.stopStream();
                mPlayer = null;
                playState = false;
            }
            else {
                Log.d("Player", "Play Called");
                createMediaPlayer();
                getAudioFocus();

                try {
                    mPlayer.setDataSource(shoutcast.startStream());
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (SecurityException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalStateException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (MalformedURLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvalidStreamURLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                mPlayer.prepareAsync();
            }
        }
    };

    private void createMediaPlayer() {
        mPlayer = new MediaPlayer();

        // Make sure the media player will acquire a wake-lock while
        // playing. If we don't do
        // that, the CPU might go to sleep while the song is playing,
        // causing playback to stop.
        //
        // Remember that to use this, we have to declare the
        // android.permission.WAKE_LOCK
        // permission in AndroidManifest.xml.
        mPlayer.setWakeMode(getApplicationContext(),
                PowerManager.PARTIAL_WAKE_LOCK);

        // we want the media player to notify us when it's ready preparing,
        // and when it's done
        // playing:
        mPlayer.setOnPreparedListener(this);
        mPlayer.setOnCompletionListener(this);
        mPlayer.setOnErrorListener(this);
    }

    private void startPlayer() {
        mPlayer.setVolume(1.0f, 1.0f);
        if (!mPlayer.isPlaying()) {
            Log.d("Player", "Starting Playback");
            mPlayer.start();
            playState = true;
            status.setText("Streaming");
        }               
    }

    private void getAudioFocus() {
        if (mAudioFocus != AudioFocus.Focused && mAudioFocusHelper != null
                && mAudioFocusHelper.requestFocus())
            mAudioFocus = AudioFocus.Focused;
    }

    private void giveUpAudioFocus() {
        if (mAudioFocus == AudioFocus.Focused && mAudioFocusHelper != null
                && mAudioFocusHelper.abandonFocus())
            mAudioFocus = AudioFocus.NoFocusNoDuck;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.activity_player, menu);
        return true;
    }

    @Override
    public void onBufferingUpdate(MediaPlayer arg0, int arg1) {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean onError(MediaPlayer mp, int what, int extra) {
        playState = false;
        handler.post(handlePlayRequest);
        return false;
    }

    @Override
    public void onPrepared(MediaPlayer arg0) {
        startPlayer();      
    }

    @Override
    public void onCompletion(MediaPlayer arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void onGainedAudioFocus() {
        // TODO Auto-generated method stub

    }

    @Override
    public void onLostAudioFocus(boolean canDuck) {
        // TODO Auto-generated method stub

    }

}

My Requirement is to Convert this Activity to Service Class,I have tried but not getting,Because I'm new to Android as well as new to Programing,

Could any one help?

If you want to play background music for your app only, then play it in a thread launched from your app/use AsyncTask class to do it for you.

The concept of services is to run in the background; By background, the meaning is usually when your app UI is NOT VISIBLE. True, it can be used just like you have (If you remember to stop it) but its just not right, and it consumes resources you shouldn't be using.

If you want to peform tasks on the background of your activity, use AsyncTask.

By the way, onStart is deprecated. When you do use services, implement onStartCommand.

UPDATE:

I think this code will work for you. Add this class (Enclosed in your activity class).

  public class BackgroundSound extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... params) {
    MediaPlayer player = MediaPlayer.create(YourActivity.this, R.raw.test_cbr); 
    player.setLooping(true); // Set looping 
    player.setVolume(100,100); 
    player.start(); 
    return null;
 }
   }

Now, in order to control the music, save your BackgroundSound object instead of creating it annonymously. Declare it as a field in your activity:

    BackgroundSound mBackgroundSound = new BackgroundSound();

On your activity's onResume method, start it:

    public void onResume() {
super.onResume();
mBackgroundSound.execute(null);
}

And on your activity's onPause method, stop it:

     public void onPause() {
super.onPause();
mBackgroundSound.cancel(true);
}

This will work.