我正在用Android创建音乐播放器，但不幸的是Mediaplayer意外停止。为什么？

我正在用Android创建音乐播放器，但不幸的是Mediaplayer意外停止。如果应用程序正在打开，则没有问题。但当应用程序转到后台时，它会停止，而不显示任何日志

有人知道原因是什么吗

---

提前感谢

公共类音乐服务扩展服务实现MediaPlayer.OnPreparedListener， MediaPlayer.OnErrorListener，MediaPlayer.OnCompletionListener{

private boolean checkError = true;
public MediaPlayer mPlayer;
private Uri mSongUri;
private Bitmap mSongBitmap;


public static PlayingFragment playingFragment;
private int songDuration;

private ArrayList<Song> mListSongs;
private int SONG_POS = 0;

private final IBinder musicBind = new PlayerBinder();

private final String ACTION_STOP = "com.emptylist.tabplayer.STOP";
private final String ACTION_NEXT = "com.emptylist.tabplayer.NEXT";
private final String ACTION_PREVIOUS = "com.emptylist.tabplayer.PREVIOUS";
private final String ACTION_PAUSE = "com.emptylist.tabplayer.PAUSE";

public static final int STATE_PAUSED = 1;
public static final int STATE_PLAYING = 2;
public int mState = 0;
private static final int REQUEST_CODE_PAUSE = 101;
private static final int REQUEST_CODE_PREVIOUS = 102;
private static final int REQUEST_CODE_NEXT = 103;
private static final int REQUEST_CODE_STOP = 104;
public static int NOTIFICATION_ID = 11;
private Notification.Builder notificationBuilder;
private Notification mNotification;

private SharedPreferences prefs;
private SharedPreferences.Editor editor;

public class PlayerBinder extends Binder {

    public MusicService getService() {
        Log.d("test", "getService()");
        return MusicService.this;
    }
}

@Override
public IBinder onBind(Intent intent) {
    Log.d("test", "onBind Called ");
    return musicBind;
}

@Override
public void onCreate() {
    super.onCreate();
    mPlayer = new MediaPlayer();
    initPlayer();
    mPlayer.setOnPreparedListener(this);
    mPlayer.setOnCompletionListener(this);
    mPlayer.setOnErrorListener(this);
    notificationBuilder = new Notification.Builder(getApplicationContext());
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {

    if (intent != null) {
        String action = intent.getAction();
        if (!TextUtils.isEmpty(action)) {
            if (action.equals(ACTION_PAUSE)) {
                playPauseSong();
            } else if (action.equals(ACTION_NEXT)) {
                nextSong();
            } else if (action.equals(ACTION_PREVIOUS)) {
                previousSong();
            } else if (action.equals(ACTION_STOP)) {
                stopSong();
                stopSelf();
            }
        }
    }
    return super.onStartCommand(intent, flags, startId);
}

@Override
public boolean onUnbind(Intent intent) {
    mPlayer.stop();
    mPlayer.release();
    return false;
}

@Override
public void onCompletion(MediaPlayer mp) {

    if (checkError == false) {

        startSong(mListSongs.get(SONG_POS).getSongUri(), mListSongs.get(SONG_POS).getSongName(), mListSongs.get(SONG_POS).getmSongAlbumArt(), SONG_POS);
        checkError = true;

    } else {

        mPlayer.reset();
        try {
            if (SONG_POS != mListSongs.size() - 1) {
                SONG_POS++;
                setSongDetails(SONG_POS);

            } else {
                SONG_POS = 0;
                setSongDetails(SONG_POS);
            }
            mPlayer.setDataSource(getApplicationContext(), mListSongs.get(SONG_POS).getSongUri());
        } catch (Exception e) {
            Log.e("MUSIC SERVICE", "Error setting data source", e);
        }
        mPlayer.prepareAsync();

        if (mState == STATE_PLAYING) {
            MainActivity.imgPlayPause.setImageResource(R.drawable.pause);
        } else
            MainActivity.imgPlayPause.setImageResource(R.drawable.play);

        editor = getSharedPreferences("MusicPref", MODE_PRIVATE).edit();
        editor.putInt("SongPosition", SONG_POS);
        editor.putString("SongURI", mListSongs.get(SONG_POS).getSongUri().toString());
        editor.commit();

    }
}

@Override
public boolean onError(MediaPlayer mp, int what, int extra) {

    Log.d("EEE", String.valueOf(what) + "," + String.valueOf(extra));
    checkError = false;
    return false;
}

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

private void initPlayer() {
    mPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
    mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
    if (android.os.Build.VERSION.SDK_INT > android.os.Build.VERSION_CODES.KITKAT) {

        try {
            Class<?> cMediaTimeProvider = Class.forName("android.media.MediaTimeProvider");
            Class<?> cSubtitleController = Class.forName("android.media.SubtitleController");
            Class<?> iSubtitleControllerAnchor = Class.forName("android.media.SubtitleController$Anchor");
            Class<?> iSubtitleControllerListener = Class.forName("android.media.SubtitleController$Listener");

            Constructor constructor = cSubtitleController.getConstructor(new Class[]{Context.class, cMediaTimeProvider, iSubtitleControllerListener});

            Object subtitleInstance = constructor.newInstance(getApplicationContext(), null, null);

            Field f = cSubtitleController.getDeclaredField("mHandler");

            f.setAccessible(true);
            try {
                f.set(subtitleInstance, new Handler());
            } catch (IllegalAccessException e) {
            } finally {
                f.setAccessible(false);
            }

            Method setsubtitleanchor = mPlayer.getClass().getMethod("setSubtitleAnchor", cSubtitleController, iSubtitleControllerAnchor);

            setsubtitleanchor.invoke(mPlayer, subtitleInstance, null);
            //Log.e("", "subtitle is setted :p");
        } catch (Exception e) {
        }
    }

}

public void startSong(Uri songuri, String songName, Bitmap bitmap, int position) {

    //Set data & start playing music
    setSongDetails(position);
    mPlayer.reset();
    mState = STATE_PLAYING;
    mSongUri = songuri;
    mSongBitmap = bitmap;

    try {
        mPlayer.setDataSource(getApplicationContext(), mSongUri);
    } catch (Exception e) {
        Log.e("MUSIC SERVICE", "Error setting data source", e);
    }
    mPlayer.prepareAsync();
    if (mState == STATE_PLAYING) {
        MainActivity.imgPlayPause.setImageResource(R.drawable.pause);
    } else {
        MainActivity.imgPlayPause.setImageResource(R.drawable.play);
    }
    Log.d("EEESonfPOs", String.valueOf(position));
    editor = getSharedPreferences("MusicPref", MODE_PRIVATE).edit();
    editor.putInt("SongPosition", SONG_POS);
    editor.putString("SongURI", mListSongs.get(SONG_POS).getSongUri().toString());
    editor.commit();
    updateNotification(songName);

}

public void playPauseSong() {

    if (mState == STATE_PAUSED) {
        mState = STATE_PLAYING;
        mPlayer.start();
        MainActivity.imgPlayPause.setImageResource(R.drawable.pause);
    } else {
        mState = STATE_PAUSED;
        mPlayer.pause();
        MainActivity.imgPlayPause.setImageResource(R.drawable.play);

    }
}

public boolean isPlayingg() {
    return mPlayer.isPlaying();
}

public int getPosn() {
    return mPlayer.getCurrentPosition();
}

public int getDur() {
    int n = songDuration;
    return songDuration;
}

public void pausePlayer() {
    mPlayer.pause();
}


private void setSongDetails(int position) {

    MediaMetadataRetriever mmr = new MediaMetadataRetriever();
    byte[] rawArt;
    Bitmap art = null;
    BitmapFactory.Options bfo = new BitmapFactory.Options();

    mmr.setDataSource(getApplicationContext(), mListSongs.get(position).getSongUri());
    rawArt = mmr.getEmbeddedPicture();

    // if rawArt is null then no cover art is embedded in the file or is not
    // recognized as such.
    if (null != rawArt) {
        Bitmap bm = Bitmap.createScaledBitmap(BitmapFactory.decodeByteArray(rawArt, 0, rawArt.length, bfo),
                100, 100,
                true);
        MainActivity.imgSongArt.setImageBitmap(bm);
        MainActivity.tvSongName.setText(mListSongs.get(position).getSongName());
        MainActivity.tvSongArtist.setText(mListSongs.get(position).getmSongArtist());
    } else {
        MainActivity.imgSongArt.setImageResource(R.drawable.default_album_art);
        MainActivity.tvSongName.setText(mListSongs.get(position).getSongName());
        MainActivity.tvSongArtist.setText(mListSongs.get(position).getmSongArtist());
    }

}

public void stopSong() {
    mPlayer.stop();
    NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    manager.cancel(NOTIFICATION_ID);
    //System.exit(0);
}

public void nextSong() {

    if (SONG_POS != mListSongs.size() - 1) {
        startSong(mListSongs.get(SONG_POS + 1).getSongUri(), mListSongs.get(SONG_POS + 1).getSongName(), mListSongs.get(SONG_POS + 1).getmSongAlbumArt(), SONG_POS + 1);
        SONG_POS++;
    } else {
        SONG_POS = 0;
        startSong(mListSongs.get(0).getSongUri(), mListSongs.get(0).getSongName(), mListSongs.get(0).getmSongAlbumArt(), 0);

    }

    editor = getSharedPreferences("MusicPref", MODE_PRIVATE).edit();
    editor.putInt("SongPosition", SONG_POS);
    editor.putString("SongURI", mListSongs.get(SONG_POS).getSongUri().toString());
    editor.commit();
}

public void previousSong() {

    if (SONG_POS != 0) {
        startSong(mListSongs.get(SONG_POS - 1).getSongUri(), mListSongs.get(SONG_POS - 1).getSongName(), mListSongs.get(SONG_POS - 1).getmSongAlbumArt(), SONG_POS - 1);
        SONG_POS--;
    } else {
        startSong(mListSongs.get(mListSongs.size() - 1).getSongUri(), mListSongs.get(mListSongs.size() - 1).getSongName(), mListSongs.get(mListSongs.size() - 1).getmSongAlbumArt(), mListSongs.size() - 1);
        SONG_POS = mListSongs.size() - 1;
    }

    editor = getSharedPreferences("MusicPref", MODE_PRIVATE).edit();
    editor.putInt("SongPosition", SONG_POS);
    editor.putString("SongURI", mListSongs.get(SONG_POS).getSongUri().toString());
    editor.commit();

}

public void setSongURI(Uri uri) {
    this.mSongUri = uri;
}

public void setmSongBitmap(Bitmap mSongBitmap) {
    this.mSongBitmap = mSongBitmap;
}


public void setSelectedSong(int pos, int notification_id) {
    SONG_POS = pos;
    NOTIFICATION_ID = notification_id;
    setSongURI(mListSongs.get(SONG_POS).getSongUri());
    setmSongBitmap(mListSongs.get(SONG_POS).getmSongAlbumArt());
    showNotification();
    startSong(mListSongs.get(SONG_POS).getSongUri(), mListSongs.get(SONG_POS).getSongName(), mListSongs.get(SONG_POS).getmSongAlbumArt(), SONG_POS);
}

public void setSongList(ArrayList<Song> listSong) {
    mListSongs = listSong;
}

public void showNotification() {
    PendingIntent pendingIntent;
    Intent intent;

    NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    RemoteViews notificationView = new RemoteViews(getPackageName(), R.layout.notification_mediacontroller);

    notificationView.setTextViewText(R.id.notify_song_name, mListSongs.get(SONG_POS).getSongName());

    intent = new Intent(ACTION_STOP);
    pendingIntent = PendingIntent.getService(getApplicationContext(), REQUEST_CODE_STOP, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    notificationView.setOnClickPendingIntent(R.id.notify_btn_stop, pendingIntent);

    intent = new Intent(ACTION_PAUSE);
    pendingIntent = PendingIntent.getService(getApplicationContext(), REQUEST_CODE_PAUSE, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    notificationView.setOnClickPendingIntent(R.id.notify_btn_pause, pendingIntent);

    intent = new Intent(ACTION_PREVIOUS);
    pendingIntent = PendingIntent.getService(getApplicationContext(), REQUEST_CODE_PREVIOUS, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    notificationView.setOnClickPendingIntent(R.id.notify_btn_previous, pendingIntent);

    intent = new Intent(ACTION_NEXT);
    pendingIntent = PendingIntent.getService(getApplicationContext(), REQUEST_CODE_NEXT, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    notificationView.setOnClickPendingIntent(R.id.notify_btn_next, pendingIntent);

    mNotification = notificationBuilder
            .setSmallIcon(R.drawable.ic_launcher).setOngoing(true)
            .setWhen(System.currentTimeMillis())
            .setContent(notificationView)
            .setDefaults(Notification.FLAG_NO_CLEAR)
            .build();
    notificationManager.notify(NOTIFICATION_ID, mNotification);
}

private void updateNotification(String songName) {
    NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    mNotification.contentView.setTextViewText(R.id.notify_song_name, songName);
    mNotification.contentView.setImageViewBitmap(R.id.img_notification, mListSongs.get(SONG_POS).getmSongAlbumArt());
    notificationManager.notify(NOTIFICATION_ID, mNotification);
}

private boolean checkError=true；
公共媒体播放器mPlayer；
私有Uri mSongUri；
私有位图；
公共静态播放片段播放片段；
私人通话时长；
私人ArrayList音乐；
私密的国际宋_POS=0；
私有最终IBinder musicBind=新播放器绑定器（）；
私有最终字符串操作\u STOP=“com.emptylist.tabplayer.STOP”；
private final String ACTION_NEXT=“com.emptylist.tabplayer.NEXT”；
私有最终字符串操作\u PREVIOUS=“com.emptylist.tabplayer.PREVIOUS”；
私有最终字符串操作\u PAUSE=“com.emptylist.tabplayer.PAUSE”；
公共静态最终整数状态_=1；
公共静态最终整数状态_PLAYING=2；
公共int mState=0；
私有静态最终整数请求\代码\暂停=101；
私有静态最终整数请求\代码\先前=102；
私有静态最终整数请求\代码\下一步=103；
私有静态最终整数请求\代码\停止=104；
公共静态int通知_ID=11；
私人通知。建筑商通知建筑商；
私人通知；
私人共享参考优先权；
私有共享参考。编辑器；
公共类PlayerBinder扩展绑定器{
公共音乐服务getService（）{
Log.d（“test”，“getService（）”）；
返回MusicService.this；
}
}
@凌驾
公共IBinder onBind（意向）{
Log.d（“测试”，“调用onBind”）；
返回音乐绑定；
}
@凌驾
public void onCreate（）{
super.onCreate（）；
mPlayer=新媒体播放器（）；
initPlayer（）；
mPlayer.setOnPreparedListener（此）；
mPlayer.setOnCompletionListener（此）；
mPlayer.setOneErrorListener（此）；
notificationBuilder=new Notification.Builder（getApplicationContext（））；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
if（intent！=null）{
String action=intent.getAction（）；
如果（！TextUtils.isEmpty（操作））{
if（动作等于（动作暂停））{
playPauseSong（）；
}else if（action.equals（action_NEXT））{
nextSong（）；
}else if（action.equals（action_PREVIOUS））{
上一首歌（）；
}else if（action.equals（action_STOP））{
停止歌曲（）；
stopSelf（）；
}
}
}
返回super.onStartCommand（intent、flags、startId）；
}
@凌驾
公共布尔onUnbind（意图）{
mPlayer.stop（）；
mPlayer.release（）；
返回false；
}
@凌驾
完成时的公共作废（MediaPlayer mp）{
if（checkError==false）{
startSong（mListSongs.get（SONG_POS.getSongUri（），mListSongs.get（SONG_POS.getSongName（），mListSongs.get（SONG_POS.getmSongAlbumArt（），SONG_POS））；
checkError=true；
}否则{
mPlayer.reset（）；
试一试{
if（SONG_POS！=mListSongs.size（）-1）{
SONG_POS++；
Setsong详细信息（SONG_POS）；
}否则{
宋_POS=0；
Setsong详细信息（SONG_POS）；
}
mPlayer.setDataSource（getApplicationContext（），mListSongs.get（SONG_POS.getSongUri（））；
}捕获（例外e）{
Log.e（“音乐服务”，“错误设置数据源”，e）；
}
mPlayer.prepareAsync（）；
如果（mState==状态_播放）{
MainActivity.imgPlayPause.setImageResource（R.drawable.pause）；
}否则
MainActivity.imgPlayPause.setImageResource（R.drawable.play）；
editor=getSharedReferences（“MusicPref”，MODE_PRIVATE）.edit（）；
编辑：putInt（“SongPosition”，SONG_POS）；
putString（“SongURI”，mListSongs.get（SONG_POS.getSongUri（）.toString（））；
commit（）；
}
}
@凌驾
公共布尔onError（MediaPlayer mp，int what，int extra）{
Log.d（“EEE”，String.valueOf（what）+”，“String.valueOf（extra））；
checkError=false；
返回false；
}
@凌驾
已准备好公开作废（MediaPlayer mp）{
mp.start（）；
新的ProgressUpdater（）；
}
私有播放器（）{
mPlayer.setWakeMode（getApplicationContext（），PowerManager.PARTIAL_WAKE_LOCK）；
mPlayer.setAudioStreamType（AudioManager.STREAM_MUSIC）；
if（android.os.Build.VERSION.SDK_INT>android.os.Build.VERSION_code.KITKAT）{
试一试{
Class cMediaTimeProvider=Class.forName（“android.media.MediaTimeProvider”）；
Class cSubtitleController=Class.forName（“android.media.SubtitleController”）；
Class iSubtitleControllerAnchor=Class.forName（“android.media.SubtitleController$Anchor”）；
Class iSubtitleControllerListener=Class.forName（“android.media.SubtitleController$Listener”）；
构造函数Constructor=cSubtitleController.getConstructor（新类[]{Context.Class，cMediaTimeProvider，iSubtitleControllerListener}）；
Object instance=constructor.newInstance（getApplicationContext（），null，null）；
字段f=cSubtitleController.getDeclaredField（“mHandler”）；
f、 setAccessible（true）；
试一试{
f、 set（subtitleInstance，newhandler（））；
}捕获（非法访问例外e）{
}最后{
f、 setAccessible（false）；
}
方法setsubtitleanchor=mPlayer.getClass（）.getMethod（“setsubtitleanchor”，cSubtitleController，iSubtitleControllerAnchor）；
调用（mPlayer，subtitleanchor.invoke，null）；
//Log.e（“，”副标题设置为：p”）；
}捕获（例外e）{
}
}
}