后退按钮，在媒体播放器不工作 [英] Back button not working in Media player
本文介绍了后退按钮，在媒体播放器不工作的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我能够preSS后退按钮时，音乐不播放。但是，在播放音乐时，我尝试preSS后退按钮，这是行不通的。即使在暂停音乐，返回键不工作。请帮助可能是什么问题。在code的片段粘贴如下：
在MainActivity：
公共类MainActivity扩展活动实现MediaPlayerControl {私人的ArrayList＆LT;宋＆GT;的SongList;
私人的ListView songView;私人MusicService musicSrv;
私人意图playIntent;
私人布尔musicBound = FALSE;
私人MusicController控制器;私人布尔暂停=假，playbackPaused = FALSE;@覆盖
保护无效的onCreate（捆绑savedInstanceState）{
super.onCreate（savedInstanceState）;
的setContentView（R.layout.activity_main）; songView =（ListView控件）findViewById（R.id.lv_song_list）;
的SongList =新的ArrayList＆LT;宋＆GT;（）;
getSongList（）;
Collections.sort（的SongList，新的比较＆LT;宋＆GT;（）{
@覆盖
公众诠释比较（宋一，宋二）{
返回a.getTitle（）的compareTo（b.getTitle（））。
}
}）;
SongAdapter songAdt =新SongAdapter（这一点，的SongList）;
songView.setAdapter（songAdt）;
setController（）;
}//连接到服务
私人ServiceConnection musicConnection =新ServiceConnection（）{ @覆盖
公共无效onServiceConnected（组件名名称，服务的IBinder）{
MusicBinder粘结剂=（MusicBinder）服务;
//获得服务
musicSrv = binder.getService（）;
Log.e（主法，内线）;
//传列表
musicSrv.setList（的SongList）;
musicBound = TRUE;
} @覆盖
公共无效onServiceDisconnected（组件名名）{
Log.e（主法，内部断线）;
musicBound = FALSE;
musicSrv = NULL;
}
};@覆盖
保护无效调用onStart（）{
super.onStart（）;
如果（playIntent == NULL）{
playIntent =新意图（这一点，MusicService.class）;
bindService（playIntent，musicConnection，Context.BIND_AUTO_CREATE）;
startService（playIntent）;
Log.e（主法，里面的OnStart+ musicBound）;
}
}@覆盖
保护无效的onDestroy（）{
super.onDestroy（）;
Log.e（主法，里面的OnDestroy）;
musicSrv = NULL;}公共无效getSongList（）{
//获取歌曲信息
ContentResolver的musicResolver = getContentResolver（）;
乌里musicUri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
光标musicCursor = musicResolver.query（musicUri，NULL，NULL，NULL，
空值）; 如果（musicCursor =空＆放大器;！＆放大器; musicCursor.moveToFirst（））{
//获取列
INT titleColumn = musicCursor.getColumnIndex（MediaColumns.TITLE）;
INT idColumn = musicCursor.getColumnIndex（BaseColumns._ID）;
INT artistColumn = musicCursor.getColumnIndex（AudioColumns.ARTIST）;
//添加歌曲名单
做{
长thisId = musicCursor.getLong（idColumn）;
字符串thisTitle = musicCursor.getString（titleColumn）;
字符串thisArtist = musicCursor.getString（artistColumn）;
songList.add（新曲（thisId，thisTitle，thisArtist））;
}而（musicCursor.moveToNext（））;
}
}公共无效songPicked（查看视图）{
musicSrv.setSong（的Integer.parseInt（view.getTag（）的toString（）））;
musicSrv.playSong（）;
如果（playbackPaused）{
setController（）;
playbackPaused = FALSE;
}
controller.show（0）;
Log.d（this.getClass（）的getName（）内的歌曲挑）;
}私人无效setController（）{
//设置控制器，
控制器=新MusicController（本）;
controller.set prevNextListeners（新View.OnClickListener（）{
@覆盖
公共无效的onClick（视图v）{
playNext（）;
}
}，新View.OnClickListener（）{
@覆盖
公共无效的onClick（视图v）{
玩preV（）;
}
}）; controller.setMediaPlayer（本）;
controller.setAnchorView（findViewById（R.id.lv_song_list））;
controller.setEnabled（真）;
}//播放下
私人无效playNext（）{
musicSrv.playNext（）;
如果（playbackPaused）{
setController（）;
playbackPaused = FALSE;
}
controller.show（0）;
}//播放previous
私人无效的打法preV（）{
musicSrv.play preV（）;
如果（playbackPaused）{
setController（）;
playbackPaused = FALSE;
}
controller.show（0）;
}@覆盖
保护无效的onPause（）{
super.onPause（）;
暂停= TRUE;
musicSrv.pausePlayer（）;
}@覆盖
保护无效onResume（）{
super.onResume（）;
如果（暂停）{
setController（）;
暂停= FALSE;
}
}@覆盖
公共无效onBack pressed（）{
如果（musicSrv！= NULL）{
super.onBack pressed（）;
Log.e（主法，内部onback preSS）;
}
}//
// @覆盖
//公共布尔的onkeydown（INT键code，KeyEvent的事件）
// {
// Log.e（MAIN法，内部onkeydown1）;
//如果（（键code == KeyEvent.KEY code_BACK））
// {//返回键pressed
// //要做的事
// Log.e（MAIN法，内部onkeydown2）;
//如果（musicSrv！= NULL）
// {
// musicSrv.pausePlayer（）;
// musicSrv = NULL;
//}
//完成（）;
//返回true;
//}
//返回super.onKeyDown（键code，事件）;
//}@覆盖
保护无效的onStop（）{
Log.e（主法，里面的onStop）;
如果（playIntent！= NULL）{
Log.e（主法，内部onstop1）;
unbindService（musicConnection）;
musicBound = FALSE;
布尔flagservice = stopService（playIntent）;
Log.d（主法，内部onstop1+ flagservice）; }
controller.hide（）;
super.onStop（）;
}
@覆盖
公共无效的start（）{
Log.d（this.getClass（）的getName（），START）;
musicSrv.go（）;}@覆盖
公共无效暂停（）{
playbackPaused = TRUE;
Log.d（this.getClass（）的getName（），暂停。）;
musicSrv.pausePlayer（）;}@覆盖
公众诠释getDuration（）{
如果（musicSrv = NULL＆放大器;！＆安培; musicBound和放大器;＆安培; musicSrv.isPng（））
返回musicSrv.getDur（）;
其他
返回0;}@覆盖
公众诠释getCurrentPosition（）{ 如果（musicSrv = NULL＆放大器;！＆安培; musicBound和放大器;＆安培; musicSrv.isPng（））
返回musicSrv.getPosn（）;
其他
返回0;}@覆盖
公共无效seekTo（INT POS）{
musicSrv.seek（POS）}@覆盖
公共布尔IsPlaying模块（）{
如果（musicSrv = NULL＆放大器;！＆安培; musicBound）{
Log.e（主法，内部IsPlaying模块）;
布尔值= musicSrv.isPng（）;
返回值;
}其他
返回false;}@覆盖
公众诠释getBufferPercentage（）{
// TODO自动生成方法存根
返回0;
}@覆盖
公共布尔canPause（）{ 返回true;
}@覆盖
公共布尔canSeekBackward（）{ 返回true;
}@覆盖
公共布尔canSeekForward（）{ 返回true;
}@覆盖
公众诠释getAudioSessionId（）{ 返回0;
}
服务类：
公共类MusicService扩展服务实现
MediaPlayer.On preparedListener，MediaPlayer.OnErrorListener，
MediaPlayer.OnCompletionListener {// 媒体播放器
私人的MediaPlayer播放器;
//歌曲列表
私人的ArrayList＆LT;宋＆GT;歌曲;
// 当前位置
私人诠释songPosn;私人字符串SONGTITLE =;
私有静态最终诠释NOTIFY_ID = 1;私人布尔洗牌= FALSE;
私人随机兰特;
私人最终的IBinder musicBind =新MusicBinder（）;@覆盖
公众的IBinder onBind（意向意图）{
Log.d（this.getClass（）的getName（），装订）;
返回musicBind;
}@覆盖
公共布尔onUnbind（意向意图）{
Log.d（this.getClass（）的getName（），解除绑定。）;
如果（player.isPlaying（））{
player.stop（）;
player.release（）;
Log.d（this.getClass（）的getName（），UNBIND1）;
}
返回false;
}@覆盖
公共无效的onCreate（）{
//创建服务
//创建服务
super.onCreate（）;
//初始化位置
songPosn = 0;
如果（球员== NULL）{
//创建播放器
玩家=新的MediaPlayer（）;
initMusicPlayer（）;
} player.reset（）; 兰特=新的随机（）;
}公共无效initMusicPlayer（）{
//设置玩家的属性
player.setWakeMode（getApplicationContext（），
PowerManager.PARTIAL_WAKE_LOCK）;
player.setAudioStreamType（AudioManager.STREAM_MUSIC）; player.setOn preparedListener（本）;
player.setOnCompletionListener（本）;
player.setOnErrorListener（本）;}公共无效SETLIST（ArrayList的＆LT;宋＆GT; theSongs）{
this.songs = theSongs;
}公共类MusicBinder扩展粘结剂{
MusicService的getService（）{
返回MusicService.this;
}
}公共无效playSong（）{
//播放一首歌曲
player.reset（）;
//获取歌曲
宋playSong = songs.get（songPosn）;
SONGTITLE = playSong.getTitle（）;
//获取ID
长currSong = playSong.getId（）;
//设置URI
乌里trackUri = ContentUris.withAppendedId（
android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI，
currSong）;
尝试{
player.setDataSource（getApplicationContext（），trackUri）;
。玩家prepareAsync（）;
}赶上（抛出：IllegalArgumentException五）{
e.printStackTrace（）;
}赶上（IllegalStateException异常五）{
e.printStackTrace（）;
}赶上（IOException异常五）{
e.printStackTrace（）;
Log.e（音乐服务，错误设置数据源，E）;
} Log.d（音乐服务，内部playsong）;
}公共无效setShuffle（）{
如果（随机播放）
洗牌= FALSE;
其他
洗牌= TRUE;
}@覆盖
公共无效onCompletion（MediaPlayer的MP）{ 如果（player.isPlaying（））{
mp.stop（）;
mp.release（）; } 如果（player.getCurrentPosition（）℃，）{
mp.reset（）;
playNext（）;
}
}公共无效setSong（INT songIndex）{
this.songPosn = songIndex;
}@覆盖
公共布尔的onError（MediaPlayer的熔点，诠释了什么，整型附加）{ mp.reset（）;
Log.e（ERROR，内部的onError）;
返回false;
}@覆盖
在prepared（MediaPlayer的MP）公共无效{
如果（！player.isPlaying（））{
Log.d（this.getClass（）的getName（），关于prePARE）;
尝试
{
mp.start（）;
}
赶上（IllegalStateException异常E）
{
e.printStackTrace（）;
}
}
意图notIntent =新意图（这一点，MainActivity.class）;
notIntent.addFlags（Intent.FLAG_ACTIVITY_CLEAR_TOP）;
的PendingIntent pendInt = PendingIntent.getActivity（这一点，0，
notIntent，PendingIntent.FLAG_UPDATE_CURRENT）; Notification.Builder建设者=新Notification.Builder（本）; builder.setContentIntent（pendInt）
.setSmallIcon（R.drawable.play）
.setTicker（SONGTITLE）
.setOngoing（真）
.setContentTitle（播放）
.setContentText（SONGTITLE）;
通知不等于builder.build（）;
Log.e（音乐服务，内部prepare）;
startForeground（NOTIFY_ID，没有）;}公共无效停止（）{
如果（！player.isPlaying（））{
player.stop（）;
Log.d（音乐服务，内部停）;
}
}公众诠释getPosn（）{
返回player.getCurrentPosition（）;
}公众诠释getDur（）{
返回player.getDuration（）;
}公共布尔isPng（）{
返回player.isPlaying（）;
}公共无效pausePlayer（）{
如果（player.isPlaying（））{
player.pause（）;
}
}公共无效寻求（INT posn处）{
player.seekTo（posn处）;
}公共无效围棋（）{
如果（！player.isPlaying（））{
Log.d（this.getClass（）的getName（），GO）;
player.start（）;
}
}公共无效玩preV（）{
songPosn--;
如果（songPosn℃，）
songPosn = songs.size（） - 1;
playSong（）;
}//跳至下一
公共无效playNext（）{
songPosn ++;
如果（songPosn＆GT = songs.size（））
songPosn = 0;
playSong（）; 如果（随机播放）{
INT newSong = songPosn;
而（newSong == songPosn）{
newSong = rand.nextInt（songs.size（））;
}
songPosn = newSong;
}其他{
songPosn ++;
如果（songPosn＆下; = songs.size（））
songPosn = 0;
}
playSong（）;
}@覆盖
公共无效的onDestroy（）{
super.onDestroy（）;
Log.d（this.getClass（）的getName（），关于消灭）;
stopForeground（真）;
如果（玩家！= NULL）{
如果（player.isPlaying（））{
player.stop（）;
}
player.release（）;
}}
}
的MediaController类：
公共类MusicController扩展的MediaController {公共MusicController（上下文C）{
超（C）;
}
@覆盖
公共无效的hide（）{
Log.d（this.getClass（）的getName（），隐藏）;
super.show（）;
}
@覆盖
公共无效显示（INT超时）{
Log.d（this.getClass（）的getName（），秀）;
super.show（0）;
}@覆盖
公共布尔dispatchKeyEvent（KeyEvent的事件）
{
INT键code = event.getKey code（）;
如果（键code == KeyEvent.KEY code_BACK）
{
Log.d（this.getClass（）的getName（），DispACH）;
super.hide（）;
上下文C =的getContext（）;
（（活动）C）.finish（）;
返回true;
}
返回super.dispatchKeyEvent（事件）;
}
}
解决方案
为什么你要处理的返回键在的onkeydown 。在活动将采取自行整理的时候返回键为pressed照顾。
从活动中删除如果你的目的是处理的onkeydown 法返回键那里。
您可以停止和发布的 MediaPlayer的实例在活动 的onDestroy
另外，如果你需要做回preSS任何具体的工作，打电话之前做在 onBack pressed 方法 super.onBack pressed 。
如果在播放音乐时，需要处理的媒体控制器是可见的键，code_BACK 完成活动
在添加这是你的 MusicController 类
@覆盖
公共布尔dispatchKeyEvent（KeyEvent的事件）{
INT键code = event.getKey code（）;
如果（键code == KeyEvent.KEY code_BACK）{
完（）;
返回true;
}
返回super.dispatchKeyEvent（事件）;
}
I am able to press the back button when music is not played . But when the music plays and I try to press the back button,it doesn't work. Even on pausing the music, back button not working. Please help what could be the issue. Pasting below a snippet of the code:
Inside MainActivity:
public class MainActivity extends Activity implements MediaPlayerControl {
private ArrayList<Song> songList;
private ListView songView;
private MusicService musicSrv;
private Intent playIntent;
private boolean musicBound = false;
private MusicController controller;
private boolean paused = false, playbackPaused = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
songView = (ListView) findViewById(R.id.lv_song_list);
songList = new ArrayList<Song>();
getSongList();
Collections.sort(songList, new Comparator<Song>() {
@Override
public int compare(Song a, Song b) {
return a.getTitle().compareTo(b.getTitle());
}
});
SongAdapter songAdt = new SongAdapter(this, songList);
songView.setAdapter(songAdt);
setController();
}
// connect to the service
private ServiceConnection musicConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
MusicBinder binder = (MusicBinder) service;
// get service
musicSrv = binder.getService();
Log.e("MAIN ACT", "Inside connection");
// pass list
musicSrv.setList(songList);
musicBound = true;
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e("MAIN ACT", "Inside disconnection");
musicBound = false;
musicSrv = null;
}
};
@Override
protected void onStart() {
super.onStart();
if (playIntent == null) {
playIntent = new Intent(this, MusicService.class);
bindService(playIntent, musicConnection, Context.BIND_AUTO_CREATE);
startService(playIntent);
Log.e("MAIN ACT", "Inside onstart" + musicBound);
}
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.e("MAIN ACT", "Inside ondestroy");
musicSrv = null;
}
public void getSongList() {
// retrieve song info
ContentResolver musicResolver = getContentResolver();
Uri musicUri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
Cursor musicCursor = musicResolver.query(musicUri, null, null, null,
null);
if (musicCursor != null && musicCursor.moveToFirst()) {
// get columns
int titleColumn = musicCursor.getColumnIndex(MediaColumns.TITLE);
int idColumn = musicCursor.getColumnIndex(BaseColumns._ID);
int artistColumn = musicCursor.getColumnIndex(AudioColumns.ARTIST);
// add songs to list
do {
long thisId = musicCursor.getLong(idColumn);
String thisTitle = musicCursor.getString(titleColumn);
String thisArtist = musicCursor.getString(artistColumn);
songList.add(new Song(thisId, thisTitle, thisArtist));
} while (musicCursor.moveToNext());
}
}
public void songPicked(View view) {
musicSrv.setSong(Integer.parseInt(view.getTag().toString()));
musicSrv.playSong();
if (playbackPaused) {
setController();
playbackPaused = false;
}
controller.show(0);
Log.d(this.getClass().getName(), "Inside song picked");
}
private void setController() {
// set the controller up
controller = new MusicController(this);
controller.setPrevNextListeners(new View.OnClickListener() {
@Override
public void onClick(View v) {
playNext();
}
}, new View.OnClickListener() {
@Override
public void onClick(View v) {
playPrev();
}
});
controller.setMediaPlayer(this);
controller.setAnchorView(findViewById(R.id.lv_song_list));
controller.setEnabled(true);
}
// play next
private void playNext() {
musicSrv.playNext();
if (playbackPaused) {
setController();
playbackPaused = false;
}
controller.show(0);
}
// play previous
private void playPrev() {
musicSrv.playPrev();
if (playbackPaused) {
setController();
playbackPaused = false;
}
controller.show(0);
}
@Override
protected void onPause() {
super.onPause();
paused = true;
musicSrv.pausePlayer();
}
@Override
protected void onResume() {
super.onResume();
if (paused) {
setController();
paused = false;
}
}
@Override
public void onBackPressed() {
if (musicSrv != null){
super.onBackPressed();
Log.e("MAIN ACT", "Inside onbackpress");
}
}
//
// @Override
// public boolean onKeyDown(int keyCode, KeyEvent event)
// {
// Log.e("MAIN ACT", "Inside onkeydown1");
// if ((keyCode == KeyEvent.KEYCODE_BACK))
// { //Back key pressed
// //Things to Do
// Log.e("MAIN ACT", "Inside onkeydown2");
// if(musicSrv!= null)
// {
// musicSrv.pausePlayer();
// musicSrv=null;
// }
// finish();
// return true;
// }
// return super.onKeyDown(keyCode, event);
// }
@Override
protected void onStop() {
Log.e("MAIN ACT", "Inside onstop");
if (playIntent != null) {
Log.e("MAIN ACT", "Inside onstop1");
unbindService(musicConnection);
musicBound = false;
boolean flagservice = stopService(playIntent);
Log.d("MAIN ACT", "Inside onstop1" + flagservice);
}
controller.hide();
super.onStop();
}
@Override
public void start() {
Log.d(this.getClass().getName(), "START");
musicSrv.go();
}
@Override
public void pause() {
playbackPaused = true;
Log.d(this.getClass().getName(), "PAUSE");
musicSrv.pausePlayer();
}
@Override
public int getDuration() {
if (musicSrv != null && musicBound && musicSrv.isPng())
return musicSrv.getDur();
else
return 0;
}
@Override
public int getCurrentPosition() {
if (musicSrv != null && musicBound && musicSrv.isPng())
return musicSrv.getPosn();
else
return 0;
}
@Override
public void seekTo(int pos) {
musicSrv.seek(pos);
}
@Override
public boolean isPlaying() {
if (musicSrv != null && musicBound) {
Log.e("MAIN ACT", "Inside isplaying");
boolean value = musicSrv.isPng();
return value;
} else
return false;
}
@Override
public int getBufferPercentage() {
// TODO Auto-generated method stub
return 0;
}
@Override
public boolean canPause() {
return true;
}
@Override
public boolean canSeekBackward() {
return true;
}
@Override
public boolean canSeekForward() {
return true;
}
@Override
public int getAudioSessionId() {
return 0;
}
Service Class:
public class MusicService extends Service implements
MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener,
MediaPlayer.OnCompletionListener {
// media player
private MediaPlayer player;
// song list
private ArrayList<Song> songs;
// current position
private int songPosn;
private String songTitle = "";
private static final int NOTIFY_ID = 1;
private boolean shuffle = false;
private Random rand;
private final IBinder musicBind = new MusicBinder();
@Override
public IBinder onBind(Intent intent) {
Log.d(this.getClass().getName(), "BIND");
return musicBind;
}
@Override
public boolean onUnbind(Intent intent) {
Log.d(this.getClass().getName(), "UNBIND");
if (player.isPlaying()) {
player.stop();
player.release();
Log.d(this.getClass().getName(), "UNBIND1");
}
return false;
}
@Override
public void onCreate() {
// create the service
// create the service
super.onCreate();
// initialize position
songPosn = 0;
if (player == null) {
// create player
player = new MediaPlayer();
initMusicPlayer();
}
player.reset();
rand = new Random();
}
public void initMusicPlayer() {
// set player properties
player.setWakeMode(getApplicationContext(),
PowerManager.PARTIAL_WAKE_LOCK);
player.setAudioStreamType(AudioManager.STREAM_MUSIC);
player.setOnPreparedListener(this);
player.setOnCompletionListener(this);
player.setOnErrorListener(this);
}
public void setList(ArrayList<Song> theSongs) {
this.songs = theSongs;
}
public class MusicBinder extends Binder {
MusicService getService() {
return MusicService.this;
}
}
public void playSong() {
// play a song
player.reset();
// get song
Song playSong = songs.get(songPosn);
songTitle = playSong.getTitle();
// get id
long currSong = playSong.getId();
// set uri
Uri trackUri = ContentUris.withAppendedId(
android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
currSong);
try {
player.setDataSource(getApplicationContext(), trackUri);
player.prepareAsync();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
Log.e("MUSIC SERVICE", "Error setting data source", e);
}
Log.d("MUSIC SERVICE", "Inside playsong");
}
public void setShuffle() {
if (shuffle)
shuffle = false;
else
shuffle = true;
}
@Override
public void onCompletion(MediaPlayer mp) {
if (player.isPlaying()) {
mp.stop();
mp.release();
}
if (player.getCurrentPosition() < 0) {
mp.reset();
playNext();
}
}
public void setSong(int songIndex) {
this.songPosn = songIndex;
}
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
mp.reset();
Log.e("ERROR", "Inside onError");
return false;
}
@Override
public void onPrepared(MediaPlayer mp) {
if (!player.isPlaying()) {
Log.d(this.getClass().getName(), "ONPREPARE");
try
{
mp.start();
}
catch(IllegalStateException e)
{
e.printStackTrace();
}
}
Intent notIntent = new Intent(this, MainActivity.class);
notIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendInt = PendingIntent.getActivity(this, 0,
notIntent, PendingIntent.FLAG_UPDATE_CURRENT);
Notification.Builder builder = new Notification.Builder(this);
builder.setContentIntent(pendInt)
.setSmallIcon(R.drawable.play)
.setTicker(songTitle)
.setOngoing(true)
.setContentTitle("Playing")
.setContentText(songTitle);
Notification not = builder.build();
Log.e("MUSIC SERVICE", "Inside prepare");
startForeground(NOTIFY_ID, not);
}
public void stop() {
if (!player.isPlaying()) {
player.stop();
Log.d("MUSIC SERVICE", "Inside stop");
}
}
public int getPosn() {
return player.getCurrentPosition();
}
public int getDur() {
return player.getDuration();
}
public boolean isPng() {
return player.isPlaying();
}
public void pausePlayer() {
if (player.isPlaying()) {
player.pause();
}
}
public void seek(int posn) {
player.seekTo(posn);
}
public void go() {
if (!player.isPlaying()) {
Log.d(this.getClass().getName(), "GO");
player.start();
}
}
public void playPrev() {
songPosn--;
if (songPosn < 0)
songPosn = songs.size() - 1;
playSong();
}
// skip to next
public void playNext() {
songPosn++;
if (songPosn >= songs.size())
songPosn = 0;
playSong();
if (shuffle) {
int newSong = songPosn;
while (newSong == songPosn) {
newSong = rand.nextInt(songs.size());
}
songPosn = newSong;
} else {
songPosn++;
if (songPosn <= songs.size())
songPosn = 0;
}
playSong();
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(this.getClass().getName(), "ON DESTROY");
stopForeground(true);
if (player != null) {
if (player.isPlaying()) {
player.stop();
}
player.release();
}
}
}
MediaController class:
public class MusicController extends MediaController {
public MusicController(Context c){
super(c);
}
@Override
public void hide(){
Log.d(this.getClass().getName(),"Hide");
super.show();
}
@Override
public void show(int timeout) {
Log.d(this.getClass().getName(),"Show");
super.show(0);
}
@Override
public boolean dispatchKeyEvent(KeyEvent event)
{
int keyCode = event.getKeyCode();
if(keyCode == KeyEvent.KEYCODE_BACK)
{
Log.d(this.getClass().getName(),"DispACH");
super.hide();
Context c = getContext();
((Activity) c).finish();
return true;
}
return super.dispatchKeyEvent(event);
}
}
解决方案
Why do you want to handle the Back key in onKeyDown . The Activity will taken care of finishing itself when back key is pressed.
Remove the onKeyDown method from Activity if your aim is to handle BACK Key there.
You can stop and release the MediaPlayer Instance in Activity onDestroy
Also, If you need to do any specific work on back press , do it in onBackPressed method before calling super.onBackPressed.
If media controller is visible when music play, you need to handle the KEYCODE_BACK to finish the Activity
Add this in your MusicController class
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
int keyCode = event.getKeyCode();
if(keyCode == KeyEvent.KEYCODE_BACK){
finish();
return true;
}
return super.dispatchKeyEvent(event);
}
这篇关于后退按钮，在媒体播放器不工作的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
