Develop Reference

Issue while cancelling the Media Style Notification in android

In my android app that I am working on, I have implemented MediaPlayer service class (PlayService.java) which will play live radio audio stream from a remote source. When a service runs in the foreground, it displays a notification with play/pause media transport control so that the user can handle media player actions from there also. I am successful in doing all so but the only problem I face is that when the user clear that notification from notification area the notification gets dismissed but the service won't stop. I have research alot but couldn't find any proper solution.
My working code for MediaPlayer Service class is:
public class PlayService extends Service implements MediaPlayer.OnCompletionListener,MediaPlayer.OnPreparedListener,
MediaPlayer.OnErrorListener,MediaPlayer.OnSeekCompleteListener,MediaPlayer.OnInfoListener,
MediaPlayer.OnBufferingUpdateListener,AudioManager.OnAudioFocusChangeListener {
private AudioManager audioManager;
private MediaPlayer mediaPlayer = new MediaPlayer();
private String sentAudioLink="";
//Used to pause/resume MediaPlayer
private int resumePosition;
//Handle notification in system tray
private NotificationCompat.Builder builder;
private NotificationManager notificationManager;
private int notification_id;
private RemoteViews remoteViews;
public static final String ACTION_PLAY = "com.example.ACTION_PLAY";
public static final String ACTION_PAUSE = "com.example.ACTION_PAUSE";
public static final String ACTION_STOP = "com.example.ACTION_STOP";
//MediaSession
private MediaSessionManager mediaSessionManager;
private MediaSessionCompat mediaSession;
private MediaControllerCompat.TransportControls transportControls;
//AudioPlayer notification ID
private static final int NOTIFICATION_ID = 101;
#Override
public void onCreate() {
mediaPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
mediaPlayer.setOnCompletionListener(this);
mediaPlayer.setOnPreparedListener(this);
mediaPlayer.setOnErrorListener(this);
mediaPlayer.setOnSeekCompleteListener(this);
mediaPlayer.setOnInfoListener(this);
mediaPlayer.setOnBufferingUpdateListener(this);
mediaPlayer.reset();
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
if (bundle != null)
{
sentAudioLink = intent.getExtras().getString("sentAudioLink");
}
mediaPlayer.reset();
//setup the media player data source using the strAudioLink value
if (!mediaPlayer.isPlaying()) {
try {
mediaPlayer.setDataSource(sentAudioLink);
//prepare media player
mediaPlayer.prepareAsync();
} catch (IllegalStateException e) {
Log.e("workingerror1", e.toString());
stopSelf();
} catch (IllegalArgumentException e) {
Log.e("workingerror2", e.toString());
stopSelf();
} catch (IOException e) {
Log.e("workingerror3", e.toString());
stopSelf();
}
buildNotification(PlaybackStatus.PLAYING);
}
//Handle Intent action from MediaSession.TransportControls
handleIncomingActions(intent);
return START_STICKY;
}
#Override
public void onDestroy() {
super.onDestroy();
if (mediaPlayer != null) {
removeNotification();
mediaPlayer.stop();
mediaPlayer.release();
mediaPlayer=null;
}
}
#Override
public void onBufferingUpdate(MediaPlayer mp, int percent) {
}
#Override
public void onCompletion(MediaPlayer mp) {
stopMedia();
stopSelf();
buildNotification(PlaybackStatus.PAUSED);
}
public void stopMedia() {
if (mediaPlayer.isPlaying())
mediaPlayer.stop();
}
#Override
public boolean onError(MediaPlayer mp, int what, int extra) {
return false;
}
#Override
public boolean onInfo(MediaPlayer mp, int what, int extra) {
return false;
}
#Override
public void onPrepared(MediaPlayer mp) {
playMedia();
}
public void playMedia() {
if (!mediaPlayer.isPlaying() && sentAudioLink!="") {
mediaPlayer.start();
}
}
#Override
public void onSeekComplete(MediaPlayer mp) {
}
#Nullable
#Override
public IBinder onBind(Intent intent) {
return null;
}
private void buildNotification(PlaybackStatus playbackStatus) {
int notificationAction = android.R.drawable.ic_media_pause;//needs to be initialized
PendingIntent play_pauseAction = null;
//Build a new notification according to the current state of the MediaPlayer
if (playbackStatus == PlaybackStatus.PLAYING) {
notificationAction = android.R.drawable.ic_media_pause;
//create the pause action
play_pauseAction = playbackAction(1);
} else if (playbackStatus == PlaybackStatus.PAUSED) {
notificationAction = android.R.drawable.ic_media_play;
//create the play action
play_pauseAction = playbackAction(0);
}
Bitmap largeIcon = BitmapFactory.decodeResource(getResources(),
R.drawable.uow_logo); //replace with your own image
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this,CHANNEL_ID)
.setShowWhen(false)
// Set the Notification style
.setStyle(new MediaStyle()
// Show our playback controls in the compact notification view.
.setShowActionsInCompactView(0)
.setShowCancelButton(true)
.setCancelButtonIntent(MediaButtonReceiver.buildMediaButtonPendingIntent(
this, PlaybackStateCompat.ACTION_STOP)))
// Set the Notification color
.setColor(getResources().getColor(R.color.colorPrimary))
// Set the large and small icons
.setSmallIcon(R.drawable.uow_logo)
.setLargeIcon(largeIcon)
// Set Notification content information
.setContentText("FM Radia - 101.8")
.setContentTitle("University of Wah")
.setOngoing(true)
.setAutoCancel(false)
// Add playback actions
.addAction(notificationAction, "pause", play_pauseAction)
.setDeleteIntent(MediaButtonReceiver.buildMediaButtonPendingIntent(
this, PlaybackStateCompat.ACTION_STOP));
((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).notify(NOTIFICATION_ID, notificationBuilder.build());
}
private void removeNotification() {
NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.cancel(NOTIFICATION_ID);
}
private PendingIntent playbackAction(int actionNumber) {
Intent playbackAction = new Intent(this, PlayService.class);
switch (actionNumber) {
case 0:
// Play
playbackAction.setAction(ACTION_PLAY);
return PendingIntent.getService(this, actionNumber, playbackAction, 0);
case 1:
// Pause
playbackAction.setAction(ACTION_PAUSE);
return PendingIntent.getService(this, actionNumber, playbackAction, 0);
default:
break;
}
return null;
}
private void handleIncomingActions(Intent playbackAction)
{
if (playbackAction == null || playbackAction.getAction() == null) return;
String actionString = playbackAction.getAction();
Log.e("actionString",actionString);
if (actionString.equalsIgnoreCase(ACTION_PLAY))
{
//Play the music
}
else if (actionString.equalsIgnoreCase(ACTION_PAUSE))
{
if (mediaPlayer.isPlaying())
mediaPlayer.stop();
mediaPlayer.release();
mediaPlayer = null;
buildNotification(PlaybackStatus.PAUSED);
stopSelf();
}
else(actionString.equalsIgnoreCase(ACTION_STOP))
{
if (mediaPlayer != null) {
removeNotification();
mediaPlayer.stop();
mediaPlayer.release();
mediaPlayer=null;
}
}
}
}

Android - Background audio service force closed

I am developing an audio streaming app for android devices and I have some issues about the handling of background audio service.
The expected behaviour of my app is that the audio source will be played continuously, even if the device is in stand-by mode with the screen off, but sometimes the background audio service is interrupted without any apparent reason.
To fix this problem, I have started the service with the option START_STICKY.
In this way, the service will be restarted even if it is closed for any reason, but now I can't close the service with a force close of the app and sometimes the service it will be restarted even if I want to close it!
Does anyone can suggest me a correct way to handle this job?
Here is my code:
At first I have declared the intent in the MainActivity:
Intent playbackServiceIntent;
Inside the onCreate() method of the MainActivity I have registered the service:
playbackServiceIntent = new Intent(this, BackgroundAudioService.class);
To start the audio service through the play button:
startService(playbackServiceIntent);
To stop the service through the stop button
stopService(playbackServiceIntent);
I have alse overrided the onDestroy() method of the MainActivity:
#Override
public void onDestroy() {
stopService(playbackServiceIntent);
//stopService(new Intent(this,BackgroundAudioService.class));
super.onDestroy();
}
Finally, the BackgroundAudioService class is defined as follow:
public class BackgroundAudioService extends Service implements OnCompletionListener {
public MediaPlayer mediaPlayer;
public WifiLock wifiLock;
PhoneStateListener mPhoneStateListener;
#Override
public IBinder onBind(Intent intent) {
return null;
}
#Override
public void onCreate() {
mediaPlayer = new MediaPlayer(); // raw/s.mp3
mediaPlayer.setOnCompletionListener(this);
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
try {
mediaPlayer.setDataSource(url);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
wifiLock = ((WifiManager) getSystemService(Context.WIFI_SERVICE))
.createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock");
wifiLock.acquire();
mediaPlayer.setOnBufferingUpdateListener(new OnBufferingUpdateListener() {
public void onBufferingUpdate(MediaPlayer mp, int percent) {
}
});
mPhoneStateListener = new PhoneStateListener()
{
protected boolean mWasPlayingWhenCalled = false;
#Override
public void onCallStateChanged(int state, String incomingNumber)
{
if( state == TelephonyManager.CALL_STATE_RINGING )
{ // Incoming call: Pause music
mediaPlayer.pause();
mWasPlayingWhenCalled = true;
}
else if(state == TelephonyManager.CALL_STATE_IDLE )
{ // Not in call: Play music
if( mWasPlayingWhenCalled )
{
mediaPlayer.start();
mWasPlayingWhenCalled = false;
}
}
else if( state == TelephonyManager.CALL_STATE_OFFHOOK )
{ // A call is dialing, active or on hold
mediaPlayer.pause();
mWasPlayingWhenCalled = true;
}
super.onCallStateChanged(state, incomingNumber);
}
};
TelephonyManager mgr = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
mgr.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (!mediaPlayer.isPlaying()) {
mediaPlayer.prepareAsync();
mediaPlayer.setOnPreparedListener(new OnPreparedListener() {
public void onPrepared(MediaPlayer mp) {
mediaPlayer.start();
Intent intent = new Intent();
intent.setAction("com.my_app.CUSTOM_INTENT");
sendBroadcast(intent);
}
});
Time t=new Time();
t.setToNow();
}
return START_STICKY;
}
public void onDestroy() {
if (mediaPlayer.isPlaying()) {
mediaPlayer.stop();
}
wifiLock.release();
mediaPlayer.release();
TelephonyManager mgr1 = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
if(mgr1 != null) {
mgr1.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
}
Time t=new Time();
t.setToNow();
}
public void onCompletion(MediaPlayer _mediaPlayer) {
stopSelf();
Time t=new Time();
t.setToNow();
}
}

How to send a MediaPlayer object from service to a fragment?

I building a Radio Streaming app and i am having difficulties sending my MediaPlayer object from my service to to a fragment. Below is my Service and my Fragment code. When i try to run the code it's always crashing
public class StreamService extends Service implements
MediaPlayer.OnCompletionListener,
MediaPlayer.OnPreparedListener,
MediaPlayer.OnErrorListener,
MediaPlayer.OnBufferingUpdateListener {
private static final int NOTIFICATION_ID = 1;
private PhoneStateListener phoneStateListener;
private TelephonyManager telephonyManager;
private boolean isPausedInCall = false;
private NotificationCompat.Builder builder;
//intent
private Intent bufferIntent;
public static final MediaPlayer mediaPlayer = new MediaPlayer();
ScheduledExecutorService scheduleTaskExecutor, reminderTaskExecutor;
private ScheduleModel scheduleModel;
private int currentHour;
private String currentDay, notificationTitle;
private final IBinder mBinder = new LocalBinder();
#Override
public void onCreate() {
super.onCreate();
bufferIntent = new Intent(BROADCAST_BUFFER);
mediaPlayer.setOnCompletionListener(this);
mediaPlayer.setOnPreparedListener(this);
mediaPlayer.setOnErrorListener(this);
mediaPlayer.setOnBufferingUpdateListener(this);
mediaPlayer.reset();
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
reminderTaskExecutor = Executors.newScheduledThreadPool(5);
reminderTaskExecutor.scheduleAtFixedRate(new Runnable() {
public void run() {
//initNotification();
}
}, 0, 1, TimeUnit.MINUTES);
telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
phoneStateListener = new PhoneStateListener() {
#Override
public void onCallStateChanged(int state, String incomingNumber) {
switch (state) {
case TelephonyManager.CALL_STATE_OFFHOOK:
case TelephonyManager.CALL_STATE_RINGING:
if (mediaPlayer != null) {
pauseMedia();
isPausedInCall = true;
}
break;
case TelephonyManager.CALL_STATE_IDLE:
if (mediaPlayer != null) {
if (isPausedInCall) {
isPausedInCall = false;
playMedia();
}
}
break;
}
}
};
telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
initNotification();
mediaPlayer.reset();
/**
* play media
*/
if (!mediaPlayer.isPlaying()) {
try {
mediaPlayer.setDataSource(URL_STREAM);
// sent to UI radio is buffer
sendBufferingBroadcast();
mediaPlayer.prepareAsync();
} catch (IllegalArgumentException e) {
Log.d("error", e.getMessage());
} catch (IllegalStateException e) {
Log.d("error", e.getMessage());
} catch (IOException e) {
Log.d("error", e.getMessage());
}
}
return START_STICKY;
}
public class LocalBinder extends Binder {
public StreamService getService() {
// Return this instance of LocalService so clients can call public methods
return StreamService.this;
}
}
#Override
public IBinder onBind(Intent intent) {
return mBinder;
}
#Override
public void onBufferingUpdate(MediaPlayer mediaPlayer, int i) {
}
#Override
public void onCompletion(MediaPlayer mediaPlayer) {
stopMedia();
stopSelf();
}
#Override
public boolean onError(MediaPlayer mediaPlayer, int what, int extra) {
switch (what) {
case MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
Toast.makeText(this, "Error not valid playback", Toast.LENGTH_SHORT).show();
break;
case MediaPlayer.MEDIA_ERROR_SERVER_DIED:
Toast.makeText(this, "Error server died", Toast.LENGTH_SHORT).show();
break;
case MediaPlayer.MEDIA_ERROR_UNKNOWN:
Toast.makeText(this, "Error occurred, please try again", Toast.LENGTH_SHORT).show();
break;
}
return false;
}
#Override
public void onPrepared(MediaPlayer mediaPlayer) {
// sent to UI, audio has buffered
sendBufferCompleteBroadcast();
playMedia();
}
private void pauseMedia() {
if (mediaPlayer.isPlaying())
mediaPlayer.pause();
}
private void playMedia() {
if (!mediaPlayer.isPlaying()) {
mediaPlayer.start();
}
}
private void stopMedia() {
if (mediaPlayer.isPlaying())
mediaPlayer.stop();
}
/**
* sent buffering
*/
private void sendBufferingBroadcast() {
bufferIntent.putExtra("buffering", "1");
sendBroadcast(bufferIntent);
}
/**
* sent buffering complete
*/
private void sendBufferCompleteBroadcast() {
bufferIntent.putExtra("buffering", "0");
sendBroadcast(bufferIntent);
}
#Override
public void onDestroy() {
super.onDestroy();
Log.d("tag", "remove notification");
if (mediaPlayer != null) {
if (mediaPlayer.isPlaying()) {
mediaPlayer.stop();
}
mediaPlayer.release();
}
if (phoneStateListener != null) {
telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE);
}
cancelNotification();
}
}
My Fragment, code crashed on line mVisualizerView.link(StreamService.mediaPlayer);
private void startVisualizerView(){
mVisualizerView = (VisualizerView) getView().findViewById(R.id.visualizerView);
mVisualizerView.link(StreamService.mediaPlayer);
// Start with just line renderer
addLineRenderer();
}
private void startVisualizerView(){
mVisualizerView = (VisualizerView) getView().findViewById(R.id.visualizerView);
mVisualizerView.link(StreamService.mediaPlayer);
// Start with just line renderer
addLineRenderer();
}
private void startStreaming(Context context) {
stopStreaming();
try {
getActivity().startService(serviceIntent);
Toast.makeText(context, "Enjoy #Hashtag Radio...", Toast.LENGTH_SHORT).show();
} catch (Exception e) {
}
}
private void stopStreaming() {
try {
getActivity().stopService(serviceIntent);
// reset streaming tag
isStreaming = false;
Utils.setDataBooleanToSP(getActivity(), Utils.IS_STREAM, false);
} catch (Exception e) {
}
}
private void startStreaming(Context context) {
stopStreaming();
try {
getActivity().startService(serviceIntent);
startVisualizerView();
Toast.makeText(context, "Enjoy #Hashtag Radio...", Toast.LENGTH_SHORT).show();
} catch (Exception e) {
}
}
/** Defines callbacks for service binding, passed to bindService() */
private ServiceConnection mConnection = new ServiceConnection() {
#Override
public void onServiceConnected(ComponentName className,
IBinder service) {
// We've bound to LocalService, cast the IBinder and get LocalService instance
StreamService.LocalBinder binder = (StreamService.LocalBinder) service;
mService = binder.getService();
mBound = true;
}
#Override
public void onServiceDisconnected(ComponentName arg0) {
mBound = false;
}
};

weird android mediaplayer error - Error (-38,0)?

I m having a weird error! A few minutes ago there were no errors then I cleaned up the project and suddenly an error! I recently removed an error : FATAL EXCEPTION: main; Error receiving broadcast Intent ! by commenting
//seekIntent.putExtra("song_ended", "1");
//sendBroadcast(seekIntent);
in myPlayService();
Error :
05-04 02:59:04.074: E/MediaPlayer(22138): start called in state 4
05-04 02:59:04.074: E/MediaPlayer(22138): error (-38, 0)
05-04 02:59:04.075: E/MediaPlayer(22138): Error (-38,0)
myPlayService :(Service file)
public class myPlayService extends Service implements OnCompletionListener,
OnPreparedListener, OnSeekCompleteListener, OnErrorListener {
// Media Player
private MediaPlayer mp;
private int currentSongIndex;
private ArrayList<HashMap<String, String>> songsList = new ArrayList<HashMap<String, String>>();
private SongsManager songManager;
// Pausing when phone call
private boolean isPausedInCall = false;
private PhoneStateListener phoneStateListener;
private TelephonyManager telephonyManager;
// Declare headsetSwitch variable
private int headsetSwitch = 1;
// ---Variables for seekbar processing---
Intent seekIntent;
String sntSeekPos;
int intSeekPos;
int mediaPosition;
int mediaMax;
private final Handler handler = new Handler();
private int songEnded = 0;
public static final String BROADCAST_ACTION = "com.ayush.mymusicplayer.seekprogress";
public void onCreate() {
// ---Set up intent for seekbar broadcast ---
seekIntent = new Intent(BROADCAST_ACTION);
// Register headset receiver
registerReceiver(headsetReceiver, new IntentFilter(
Intent.ACTION_HEADSET_PLUG));
songManager = new SongsManager();
songsList = songManager.getPlayList();
mp = new MediaPlayer();
mp.setOnCompletionListener(this);
mp.setOnPreparedListener(this);
mp.setOnSeekCompleteListener(this);
mp.setOnErrorListener(this);
mp.reset();
}
public int onStartCommand(Intent intent, int flags, int startId) {
// ---Set up receiver for State change ---
registerReceiver(broadcastActivityReceiver, new IntentFilter(
MyMainActivity.BROADCASTING));
// ---Set up receiver for seekbar change ---
registerReceiver(broadcastReceiver, new IntentFilter(
MyMainActivity.BROADCAST_SEEKBAR));
// Manage incoming phone calls during playback. Pause mp on incoming,
// resume on hangup.
// -----------------------------------------------------------------------------------
// Get the telephony manager
telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
phoneStateListener = new PhoneStateListener() {
#Override
public void onCallStateChanged(int state, String incomingNumber) {
switch (state) {
case TelephonyManager.CALL_STATE_OFFHOOK:
case TelephonyManager.CALL_STATE_RINGING:
if (mp != null) {
pauseMedia();
isPausedInCall = true;
}
break;
case TelephonyManager.CALL_STATE_IDLE:
// Phone idle. Start playing.
if (mp != null) {
if (isPausedInCall) {
isPausedInCall = false;
playMedia();
}
}
break;
}
}
};
// Register the listener with the telephony manager
telephonyManager.listen(phoneStateListener,
PhoneStateListener.LISTEN_CALL_STATE);
// Getting song Index from MyMainActivity
currentSongIndex = intent.getExtras().getInt("currentSongIndex");
mp.reset();
if (!mp.isPlaying()) {
try {
mp.setDataSource(songsList.get(currentSongIndex)
.get("songPath"));
mp.prepareAsync();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
}
}
// --- Set up seekbar handler ---
setupHandler();
return START_STICKY;
}
// If headset gets unplugged, stop music and service.
private BroadcastReceiver headsetReceiver = new BroadcastReceiver() {
private boolean headsetConnected = false;
#Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
if (intent.hasExtra("state")) {
if (headsetConnected && intent.getIntExtra("state", 0) == 0) {
headsetConnected = false;
headsetSwitch = 0;
} else if (!headsetConnected
&& intent.getIntExtra("state", 0) == 1) {
headsetConnected = true;
headsetSwitch = 1;
}
}
switch (headsetSwitch) {
case (0):
pauseMedia();
break;
case (1):
playMedia();
break;
}
}
};
// ---Send seekbar info to activity----
private void setupHandler() {
handler.removeCallbacks(sendUpdatesToUI);
handler.postDelayed(sendUpdatesToUI, 250); // 0.25 second
}
private Runnable sendUpdatesToUI = new Runnable() {
public void run() {
LogMediaPosition();
handler.postDelayed(this, 250); // 0.25 seconds
}
};
private void LogMediaPosition() {
if (mp.isPlaying()) {
mediaPosition = mp.getCurrentPosition();
mediaMax = mp.getDuration();
seekIntent.putExtra("counter", String.valueOf(mediaPosition));
seekIntent.putExtra("mediamax", String.valueOf(mediaMax));
seekIntent.putExtra("song_ended", String.valueOf(songEnded));
sendBroadcast(seekIntent);
}
}
// --Receive seekbar position if it has been changed by the user in the
// activity
private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
#Override
public void onReceive(Context context, Intent intent) {
updateSeekPos(intent);
}
};
// Update seek position from Activity
public void updateSeekPos(Intent intent) {
int seekPos = intent.getIntExtra("seekpos", 0);
if (mp.isPlaying()) {
handler.removeCallbacks(sendUpdatesToUI);
mp.seekTo(seekPos);
setupHandler();
}
}
// Play Song After Complition !
#Override
public void onSeekComplete(MediaPlayer mp) {
if (!mp.isPlaying()) {
playMedia();
}
}
public void onPrepared(MediaPlayer arg0) {
// Send a message to activity to end progress dialogue
playMedia();
}
// Set up broadcast receiver
private BroadcastReceiver broadcastActivityReceiver = new BroadcastReceiver() {
#Override
public void onReceive(Context context, Intent broadcastIntent) {
String broadcastValue = broadcastIntent
.getStringExtra("Broadcasting");
int broadcastIntValue = Integer.parseInt(broadcastValue);
switch (broadcastIntValue) {
case 0:
pauseMedia();
break;
case 1:
playMedia();
break;
}
}
};
public void pauseMedia() {
if (mp.isPlaying()) {
mp.pause();
}
}
public void playMedia() {
if (!mp.isPlaying()) {
mp.start();
}
}
#Override
public void onCompletion(MediaPlayer arg0) {
seekIntent.putExtra("song_ended", "1");
sendBroadcast(seekIntent);
stopSelf();
}
#Override
public void onDestroy() {
super.onDestroy();
if (mp != null) {
if (mp.isPlaying()) {
mp.stop();
}
mp.reset();
mp.release();
}
if (phoneStateListener != null) {
telephonyManager.listen(phoneStateListener,
PhoneStateListener.LISTEN_NONE);
}
// Stop the seekbar handler from sending updates to UI
handler.removeCallbacks(sendUpdatesToUI);
unregisterReceiver(headsetReceiver);
// Unregister seekbar receiver
unregisterReceiver(broadcastReceiver);
unregisterReceiver(broadcastActivityReceiver);
stopSelf();
}
// ---Error processing ---
#Override
public boolean onError(MediaPlayer mp, int what, int extra) {
switch (what) {
case MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
Toast.makeText(this,
"MEDIA ERROR NOT VALID FOR PROGRESSIVE PLAYBACK " + extra,
Toast.LENGTH_SHORT).show();
break;
case MediaPlayer.MEDIA_ERROR_SERVER_DIED:
Toast.makeText(this, "MEDIA ERROR SERVER DIED " + extra,
Toast.LENGTH_SHORT).show();
break;
case MediaPlayer.MEDIA_ERROR_UNKNOWN:
Toast.makeText(this, "MEDIA ERROR UNKNOWN " + extra,
Toast.LENGTH_SHORT).show();
break;
}
return false;
}
#Override
public IBinder onBind(Intent arg0) {
// TODO Auto-generated method stub
return null;
}
}
MyMainActivity :
public class MyMainActivity extends Activity implements OnSeekBarChangeListener {
private ImageButton btnPlay;
private ImageButton btnForward;
private ImageButton btnBackward;
private ImageButton btnNext;
private ImageButton btnPrevious;
private ImageButton btnPlaylist;
private ImageButton btnRepeat;
private ImageButton btnShuffle;
private TextView songTitleLabel;
private TextView songCurrentDurationLabel;
private TextView songTotalDurationLabel;
private SeekBar songProgressBar;
private int seekMax;
private int seekProgress;
private static int songEnded = 0;
boolean mBroadcastIsRegistered;
private int seekPos;
private SongsManager songManager;
private Utilities utils;
private int seekForwardTime = 5000; // 5000 milliseconds
private int seekBackwardTime = 5000; // 5000 milliseconds
private int currentSongIndex = 0;
private boolean isShuffle = false;
private boolean isRepeat = false;
private boolean startedPlaying = false;
private boolean paused = false;
private ArrayList<HashMap<String, String>> songsList = new ArrayList<HashMap<String, String>>();
Intent serviceIntent;
// Broadcasting
Intent broadcastStateIntent;
public static final String BROADCASTING = "com.ayush.mymusicplayer.broadcasting";
// --Set up constant ID for broadcast of seekbar position--
public static final String BROADCAST_SEEKBAR = "com.ayush.mymusicplayer.sendseekbar";
Intent intent;
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.player);
try {
// All player buttons
btnPlay = (ImageButton) findViewById(R.id.btnPlay);
btnForward = (ImageButton) findViewById(R.id.btnForward);
btnBackward = (ImageButton) findViewById(R.id.btnBackward);
btnNext = (ImageButton) findViewById(R.id.btnNext);
btnPrevious = (ImageButton) findViewById(R.id.btnPrevious);
btnPlaylist = (ImageButton) findViewById(R.id.btnPlaylist);
btnRepeat = (ImageButton) findViewById(R.id.btnRepeat);
btnShuffle = (ImageButton) findViewById(R.id.btnShuffle);
songProgressBar = (SeekBar) findViewById(R.id.songProgressBar);
songTitleLabel = (TextView) findViewById(R.id.songTitle);
songCurrentDurationLabel = (TextView) findViewById(R.id.songCurrentDurationLabel);
songTotalDurationLabel = (TextView) findViewById(R.id.songTotalDurationLabel);
songManager = new SongsManager();
utils = new Utilities();
// --- set up seekbar intent for broadcasting new position to
// service ---
intent = new Intent(BROADCAST_SEEKBAR);
broadcastStateIntent = new Intent(BROADCASTING);
// songProgressBar.setOnSeekBarChangeListener(this); // Important
serviceIntent = new Intent(this, myPlayService.class);
// Getting all songs list
songsList = songManager.getPlayList();
// set the starting title song
songTitleLabel.setText(songsList.get(0).get("songTitle"));
// registerReceiver(broadcastServiceReceiver, new IntentFilter(
// myPlayService.BROADCASTING_FROM_SERVICE));
// Listeners
songProgressBar.setOnSeekBarChangeListener(this);
/**
* Play button click event
* plays a song and changes button to pause image
* pauses a song and changes button to play image
* */
btnPlay.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
// check for already playing
if (startedPlaying == false && paused == false) {
// Changing button image to pause button
btnPlay.setImageResource(R.drawable.btn_pause);
playSong(currentSongIndex);
startedPlaying = true;
paused = false;
} else if (startedPlaying == false && paused == true) {
// Changing button image to play button
btnPlay.setImageResource(R.drawable.btn_pause);
resumingBroadcast();
paused = false;
startedPlaying = true;
}
else if (startedPlaying == true && paused == false) {
// Changing button image to play button
btnPlay.setImageResource(R.drawable.btn_play);
pausingBroadcast();
paused = true;
startedPlaying = false;
}
}
});
/**
* Forward button click event Forwards song specified seconds
* */
btnForward.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
// check if seekForward time is lesser than song duration
if (seekProgress + seekForwardTime <= seekMax) {
// forward song
seekPos = seekProgress + seekForwardTime;
intent.putExtra("seekpos", seekPos);
sendBroadcast(intent);
} else {
// forward to end position
seekPos = seekMax;
intent.putExtra("seekpos", seekPos);
sendBroadcast(intent);
}
}
});
/**
* Backward button click event Backward song to specified seconds
* */
btnBackward.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
// check if seekBackward time is greater than 0 sec
if (seekProgress - seekBackwardTime >= 0) {
// forward song
seekPos = seekProgress + seekBackwardTime;
intent.putExtra("seekpos", seekPos);
sendBroadcast(intent);
} else {
// backward to starting position
intent.putExtra("seekpos", 0);
sendBroadcast(intent);
}
}
});
/**
* Button Click event for Play list click event Launches list
* activity which displays list of songs
* */
btnPlaylist.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
Intent i = new Intent(getApplicationContext(),
PlayListActivity.class);
startActivityForResult(i, 100);
}
});
/**
* Next button click event Plays next song by taking
* currentSongIndex + 1
* */
btnNext.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
if (isShuffle) {
// shuffle is on - play a random song
Random rand = new Random();
currentSongIndex = rand.nextInt((songsList.size() - 1) - 0 + 1) + 0;
playSong(currentSongIndex);
} else {
// check if next song is there or not
if (currentSongIndex < (songsList.size() - 1)) {
playSong(currentSongIndex + 1);
currentSongIndex = currentSongIndex + 1;
} else {
// play first song
playSong(0);
currentSongIndex = 0;
}
}
}
});
/**
* Back button click event Plays previous song by currentSongIndex -
* 1
* */
btnPrevious.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
if (isShuffle) {
// shuffle is on - play a random song
Random rand = new Random();
currentSongIndex = rand.nextInt((songsList.size() - 1) - 0 + 1) + 0;
playSong(currentSongIndex);
} else {
if (currentSongIndex > 0) {
playSong(currentSongIndex - 1);
currentSongIndex = currentSongIndex - 1;
} else {
// play last song
playSong(songsList.size() - 1);
currentSongIndex = songsList.size() - 1;
}
}
}
});
/**
* Button Click event for Repeat button Enables repeat flag to true
* */
btnRepeat.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
if (isRepeat) {
isRepeat = false;
Toast.makeText(getApplicationContext(),
"Repeat is OFF", Toast.LENGTH_SHORT).show();
btnRepeat.setImageResource(R.drawable.btn_repeat);
} else {
// make repeat to true
isRepeat = true;
Toast.makeText(getApplicationContext(), "Repeat is ON",
Toast.LENGTH_SHORT).show();
// make shuffle to false
isShuffle = false;
btnRepeat
.setImageResource(R.drawable.btn_repeat_focused);
btnShuffle.setImageResource(R.drawable.btn_shuffle);
}
}
});
/**
* Button Click event for Shuffle button Enables shuffle flag to
* true
* */
btnShuffle.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View arg0) {
if (isShuffle) {
isShuffle = false;
Toast.makeText(getApplicationContext(),
"Shuffle is OFF", Toast.LENGTH_SHORT).show();
btnShuffle.setImageResource(R.drawable.btn_shuffle);
} else {
// make repeat to true
isShuffle = true;
Toast.makeText(getApplicationContext(),
"Shuffle is ON", Toast.LENGTH_SHORT).show();
// make shuffle to false
isRepeat = false;
btnShuffle
.setImageResource(R.drawable.btn_shuffle_focused);
btnRepeat.setImageResource(R.drawable.btn_repeat);
}
}
});
} catch (Exception e) {
e.printStackTrace();
Toast.makeText(getApplicationContext(),
e.getClass().getName() + " " + e.getMessage(),
Toast.LENGTH_LONG).show();
}
}
/**
* Receiving song index from playlist view and play the song
* */
#Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == 100) {
currentSongIndex = data.getExtras().getInt("songIndex");
// play selected song
playSong(currentSongIndex);
}
}
// -- onPause, unregister broadcast receiver. To improve, also save screen data ---
#Override
protected void onPause() {
// Unregister broadcast receiver
if (mBroadcastIsRegistered) {
unregisterReceiver(broadcastReceiver);
mBroadcastIsRegistered = false;
}
super.onPause();
}
// -- onResume register broadcast receiver. To improve, retrieve saved screen data ---
#Override
protected void onResume() {
// Register broadcast receiver
if (!mBroadcastIsRegistered) {
registerReceiver(broadcastReceiver, new IntentFilter(
myPlayService.BROADCAST_ACTION));
mBroadcastIsRegistered = true;
}
super.onResume();
}
// -- Broadcast Receiver to update position of seekbar from service --
private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent serviceIntent) {
updateUI(serviceIntent);
}
};
private void updateUI(Intent serviceIntent) {
String counter = serviceIntent.getStringExtra("counter");
String mediamax = serviceIntent.getStringExtra("mediamax");
String strSongEnded = serviceIntent.getStringExtra("song_ended");
seekProgress = Integer.parseInt(counter);
seekMax = Integer.parseInt(mediamax);
songEnded = Integer.parseInt(strSongEnded);
songProgressBar.setMax(seekMax);
songProgressBar.setProgress(seekProgress);
// Displaying Total Duration time
songTotalDurationLabel.setText("" + utils.milliSecondsToTimer(seekMax));
// Displaying time completed playing
songCurrentDurationLabel.setText(""
+ utils.milliSecondsToTimer(seekProgress));
if (songEnded == 1) {
// check for repeat is ON or OFF
if (isRepeat) {
// repeat is on play same song again
playSong(currentSongIndex);
} else if (isShuffle) {
// shuffle is on - play a random song
Random rand = new Random();
currentSongIndex = rand.nextInt((songsList.size() - 1) - 0 + 1) + 0;
playSong(currentSongIndex);
} else {
// no repeat or shuffle ON - play next song
if (currentSongIndex < (songsList.size() - 1)) {
playSong(currentSongIndex + 1);
currentSongIndex = currentSongIndex + 1;
} else {
// play first song
playSong(0);
currentSongIndex = 0;
}
}
}
}
// Send a message to Server to pause
private void pausingBroadcast() {
// Log.v(TAG, "BufferCompleteSent");
broadcastStateIntent.putExtra("Broadcasting", "0");
paused = true;
btnPlay.setImageResource(R.drawable.btn_play);
sendBroadcast(broadcastStateIntent);
}
// Send a message to Server to resume
private void resumingBroadcast() {
broadcastStateIntent.putExtra("Broadcasting", "1");
paused = false;
btnPlay.setImageResource(R.drawable.btn_pause);
sendBroadcast(broadcastStateIntent);
}
// Function to play a song
public void playSong(int songIndex) {
stopMyPlayService();
paused = false;
startedPlaying = true;
serviceIntent.putExtra("currentSongIndex", songIndex);
// -- Register receiver for seekbar--
registerReceiver(broadcastReceiver, new IntentFilter(
myPlayService.BROADCAST_ACTION));
mBroadcastIsRegistered = true;
try {
startService(serviceIntent);
// Displaying Song title
String songTitle = songsList.get(songIndex).get("songTitle");
songTitleLabel.setText(songTitle);
// Changing Button Image to pause image
btnPlay.setImageResource(R.drawable.btn_pause);
// set Progress bar values
songProgressBar.setProgress(0);
songProgressBar.setMax(100);
} catch (Exception e) {
e.printStackTrace();
Toast.makeText(getApplicationContext(),
e.getClass().getName() + " " + e.getMessage(),
Toast.LENGTH_LONG).show();
}
}
private void stopMyPlayService() {
// --Unregister broadcastReceiver for seekbar
if (mBroadcastIsRegistered) {
try {
unregisterReceiver(broadcastReceiver);
mBroadcastIsRegistered = false;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
Toast.makeText(
getApplicationContext(),
e.getClass().getName() + " " + e.getMessage(),
Toast.LENGTH_LONG).show();
}
}
try {
stopService(serviceIntent);
} catch (Exception e) {
e.printStackTrace();
Toast.makeText(getApplicationContext(),
e.getClass().getName() + " " + e.getMessage(),
Toast.LENGTH_LONG).show();
}
}
// --- When user manually moves seekbar, broadcast new position to service
#Override
public void onProgressChanged(SeekBar sb, int progress, boolean fromUser) {
// TODO Auto-generated method stub
if (fromUser) {
seekPos = sb.getProgress();
intent.putExtra("seekpos", seekPos);
sendBroadcast(intent);
}
}
#Override
public void onStartTrackingTouch(SeekBar arg0) {
// TODO Auto-generated method stub
}
#Override
public void onStopTrackingTouch(SeekBar arg0) {
// TODO Auto-generated method stub
}
}

The problem seems to be that you call reset() before calling isPlaying() here:
mp.reset();
if (!mp.isPlaying()) {
according the MediaPlayer documentation after calling reset() the MediaPlayer will move into its uninitialized "idle" state. Then calling isPlaying() on an uninitialized state MediaPlayer will then throw an IllegalStateException.
==> After resetting the Mediaplayer you will need to initialize / prepare it again before you can start it again

Android: Music Player gets started itself after sometime

In my app, I am using media player in service for playing a music file. It is working but eventually gets started itself after sometime, and music starts playing. I am not getting where is the problem. Below, I am posting my code:
Media Player Service
public class ChalisaService extends Service implements OnCompletionListener
{
static MediaPlayer mediaPlayer;
static int playerFlag = 0;
TelephonyManager tm;
ActivityManager actManager;
/**
* 0 for stop/pause
* 1 for play*/
#Override
public IBinder onBind(Intent intent)
{
return null;
}//onBind
#Override
public void onCreate()
{
super.onCreate();
mediaPlayer = MediaPlayer.create(getApplicationContext(), R.raw.chalisa);
mediaPlayer.setVolume(100, 100);
mediaPlayer.setOnCompletionListener(this);
tm = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
tm.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE);
}//onCreate
#Override
public int onStartCommand(Intent intent, int flags, int startId)
{
if(mediaPlayer.isPlaying())
{
mediaPlayer.pause();
/*HanuAlarm.txtPlay.setText("Play");
HanuAlarm.btn_Play.setBackgroundResource(R.drawable.btnplay);*/
playerFlag = 0;
}//if
else
{
mediaPlayer.start();
/*HanuAlarm.txtPlay.setText("Pause");
HanuAlarm.btn_Play.setBackgroundResource(R.drawable.btnpause);*/
playerFlag = 1;
}//else
startForeground(0, null);
return playerFlag;
}//onStartCommand
#Override
public void onDestroy()
{
super.onDestroy();
/*//mediaPlayer.stop();
//mediaPlayer.release();
playerFlag = 0;
Log.v("Chalisa service", "on destroy called");*/
}//onDestroy
private PhoneStateListener mPhoneListener = new PhoneStateListener() {
public void onCallStateChanged(int state, String incomingNumber) {
switch (state) {
case TelephonyManager.CALL_STATE_RINGING:
if(mediaPlayer.isPlaying())
{
mediaPlayer.pause();
playerFlag = 0;
}//if
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
if(mediaPlayer.isPlaying())
{
mediaPlayer.pause();
playerFlag = 0;
}//if
break;
/**
* Nitish
* 26 Sep 2012, Wed
* 11:50 AM*/
case TelephonyManager.CALL_STATE_IDLE:
if(!mediaPlayer.isPlaying())
{
mediaPlayer.start();
playerFlag = 1;
}//if
default:
Log.d("Chalisa Service", "Unknown phone state=" + state);
}
}
};
public void onCompletion(MediaPlayer mp)
{
mp.stop();
mp.release();
playerFlag = 0;
stopSelf();
updateUI();
Log.v("Chalisa Service media player", "on completion listener called");
}
private void updateUI()
{
Intent in = new Intent("com.dzo.HanumanChalisaWithAudioAndAlarm.UPDATE_UI");
in.putExtra("Player_FLAG_VALUE", playerFlag);
getApplicationContext().sendBroadcast(in);
}
}//ChalisaService