E/WindowManager:android.view.WindowManager错误

我正在尝试构建一个android音乐播放器应用程序，如中所述

当我能够播放音乐时，在通知托盘中单击播放器图标时，我收到错误消息

E/WindowManager: android.view.WindowLeaked: .MainActivity has leaked window com.android.internal.policy.impl.PhoneWindow$DecorView.

从通知栏调用播放机后，调用MediaController.show（）时引发错误

花了很多时间浏览各种类似的问题，但没有一个适合我的情况。非常感谢您的帮助。多谢各位

主要活动：

   public class MainActivity extends Activity implements MediaPlayerControl {

    //song list variables
    private ArrayList<Song> songList;
    private ListView songView;

    //service
    private MusicService musicSrv;
    private Intent playIntent;
    //binding
    private boolean musicBound=false;

    //controller
    private MusicController controller;

    //activity and playback pause flags
    private boolean paused=false, playbackPaused=false;

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

        //retrieve list view
        songView = (ListView)findViewById(R.id.song_list);
        //instantiate list
        songList = new ArrayList<Song>();
        //get songs from device
        getSongList();
        //sort alphabetically by title
        Collections.sort(songList, new Comparator<Song>(){
            public int compare(Song a, Song b){
                return a.getTitle().compareTo(b.getTitle());
            }
        });
        //create and set adapter
        SongAdapter songAdt = new SongAdapter(this, songList);
        songView.setAdapter(songAdt);

        //setup controller
        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();
            //pass list
            musicSrv.setList(songList);
            musicBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            musicBound = false;
        }
    };

    //start and bind the service when the activity starts
    @Override
    protected void onStart() {
        super.onStart();
        if(playIntent==null){
            playIntent = new Intent(this, MusicService.class);
            bindService(playIntent, musicConnection, Context.BIND_AUTO_CREATE);
            startService(playIntent);
        }
    }

    //user song select
    public void songPicked(View view){
        musicSrv.setSong(Integer.parseInt(view.getTag().toString()));
        musicSrv.playSong();
        if(playbackPaused){
            setController();
            playbackPaused=false;
        }
        controller.show(0);
    }

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

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        //menu item selected
        switch (item.getItemId()) {
        case R.id.action_shuffle:
            musicSrv.setShuffle();
            break;
        case R.id.action_end:
            stopService(playIntent);
            musicSrv=null;
            System.exit(0);
            break;
        }
        return super.onOptionsItemSelected(item);
    }

    //method to retrieve song info from device
    public void getSongList(){
        //query external audio
        ContentResolver musicResolver = getContentResolver();
        Uri musicUri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
        Cursor musicCursor = musicResolver.query(musicUri, null, null, null, null);
        //iterate over results if valid
        if(musicCursor!=null && musicCursor.moveToFirst()){
            //get columns
            int titleColumn = musicCursor.getColumnIndex
                    (android.provider.MediaStore.Audio.Media.TITLE);
            int idColumn = musicCursor.getColumnIndex
                    (android.provider.MediaStore.Audio.Media._ID);
            int artistColumn = musicCursor.getColumnIndex
                    (android.provider.MediaStore.Audio.Media.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());
        }
    }

    //set the controller up
    private void setController(){
        controller = new MusicController(this);
        //set previous and next button listeners
        controller.setPrevNextListeners(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                playNext();
            }
        }, new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                playPrev();
            }
        });
        //set and show
        controller.setMediaPlayer(this);
        controller.setAnchorView(findViewById(R.id.song_list));
        controller.setEnabled(true);
    }

    private void playNext(){
        musicSrv.playNext();
        if(playbackPaused){ 
            setController();
            playbackPaused=false;
        }
        controller.show(0);
    }

    private void playPrev(){
        musicSrv.playPrev();
        if(playbackPaused){
            setController();
            playbackPaused=false;
        }
        controller.show(0);
    }

    @Override
    protected void onResume(){
        super.onResume();
        if(paused){
            setController();
            paused=false;
        }
    }

    @Override
    protected void onDestroy() {
        stopService(playIntent);
        musicSrv=null;
        super.onDestroy();
    }
}

音乐服务：

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;
    //binder
    private final IBinder musicBind = new MusicBinder();
    //title of current song
    private String songTitle="";
    //notification id
    private static final int NOTIFY_ID=1;
    //shuffle flag and random
    private boolean shuffle=false;
    private Random rand;

    public void onCreate(){
        //create the service
        super.onCreate();
        //initialize position
        songPosn=0;
        //random
        rand=new Random();
        //create player
        player = new MediaPlayer();
        //initialize
        initMusicPlayer();
    }

    public void initMusicPlayer(){
        //set player properties
        player.setWakeMode(getApplicationContext(), 
                PowerManager.PARTIAL_WAKE_LOCK);
        player.setAudioStreamType(AudioManager.STREAM_MUSIC);
        //set listeners
        player.setOnPreparedListener(this);
        player.setOnCompletionListener(this);
        player.setOnErrorListener(this);
    }

    //pass song list
    public void setList(ArrayList<Song> theSongs){
        songs=theSongs;
    }

    //binder
    public class MusicBinder extends Binder {
        MusicService getService() { 
            return MusicService.this;
        }
    }

    //activity will bind to service
    @Override
    public IBinder onBind(Intent intent) {
        return musicBind;
    }

    //release resources when unbind
    @Override
    public boolean onUnbind(Intent intent){
        player.stop();
        player.release();
        return false;
    }

    //play a song
    public void playSong(){
        //play
        player.reset();
        //get song
        Song playSong = songs.get(songPosn);
        //get title
        songTitle=playSong.getTitle();
        //get id
        long currSong = playSong.getID();
        //set uri
        Uri trackUri = ContentUris.withAppendedId(
                android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
                currSong);
        //set the data source
        try{ 
            player.setDataSource(getApplicationContext(), trackUri);
        }
        catch(Exception e){
            Log.e("MUSIC SERVICE", "Error setting data source", e);
        }
        player.prepareAsync(); 
    }

    //set the song
    public void setSong(int songIndex){
        songPosn=songIndex; 
    }

    @Override
    public void onCompletion(MediaPlayer mp) {
        //check if playback has reached the end of a track
        if(player.getCurrentPosition()>0){
            mp.reset();
            playNext();
        }
    }

    @Override
    public boolean onError(MediaPlayer mp, int what, int extra) {
        Log.v("MUSIC PLAYER", "Playback Error");
        mp.reset();
        return false;
    }

    @Override
    public void onPrepared(MediaPlayer mp) {
        //start playback
        mp.start();
        //notification
        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);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);

        builder.setContentIntent(pendInt)
        .setSmallIcon(R.drawable.play)
        .setTicker(songTitle)
        .setOngoing(true)
        .setContentTitle("Playing")
        .setContentText(songTitle);
        Notification not = builder.build();
        startForeground(NOTIFY_ID, not);
    }

    //playback methods
    public int getPosn(){
        return player.getCurrentPosition();
    }

    public int getDur(){
        return player.getDuration();
    }

    public boolean isPng(){
        return player.isPlaying();
    }

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

    public void seek(int posn){
        player.seekTo(posn);
    }

    public void go(){
        player.start();
    }

    //skip to previous track
    public void playPrev(){
        songPosn--;
        if(songPosn<0) songPosn=songs.size()-1;
        playSong();
    }

    //skip to next
    public void playNext(){
        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() {
        stopForeground(true);
    }

    //toggle shuffle
    public void setShuffle(){
        if(shuffle) shuffle=false;
        else shuffle=true;
    }
 }

公共类MusicService扩展服务实现
MediaPlayer.OnPreparedListener，MediaPlayer.OnErrorListener，
MediaPlayer.OnCompletionListener{
//媒体播放器
私人媒体播放器；
//歌曲列表
私人雅乐歌曲；
//当前位置
私家车；
//活页夹
私有最终IBinder musicBind=新的MusicBinder（）；
//当前歌曲的标题
私有字符串songTitle=“”；
//通知id
私有静态final int NOTIFY_ID=1；
//随机旗和随机旗
私有布尔洗牌=false；
私有随机兰德；
public void onCreate（）{
//创建服务
super.onCreate（）；
//初始化位置
songPosn=0；
//随机的
rand=新随机数（）；
//创建玩家
player=新媒体播放器（）；
//初始化
initMusicLayer（）；
}
public void initMusicPlayer（）{
//设置玩家属性
player.setWakeMode（getApplicationContext（），
PowerManager.PARTIAL_WAKE_LOCK）；
player.setAudioStreamType（AudioManager.STREAM_MUSIC）；
//设置侦听器
player.setOnPreparedListener（此）；
player.setOnCompletionListener（此）；
player.setOneErrorListener（此）；
}
//通过歌曲列表
公共无效集合列表（数组列表歌曲）{
歌曲=歌曲；
}
//活页夹
公共类MusicBinder扩展活页夹{
MusicService getService（）{
返回MusicService.this；
}
}
//活动将绑定到服务
@凌驾
公共IBinder onBind（意向）{
返回音乐绑定；
}
//解除绑定时释放资源
@凌驾
公共布尔onUnbind（意图）{
player.stop（）；
player.release（）；
返回false；
}
//放首歌
公开播放歌曲（）{
//玩
player.reset（）；
//获得歌曲
Song playSong=songs.get（songPosn）；
//获得头衔
songTitle=playSong.getTitle（）；
//取得身份证
long currSong=playSong.getID（）；
//设置uri
Uri trackUri=ContentUris.withAppendedId(
android.provider.MediaStore.Audio.Media.EXTERNAL\u CONTENT\u URI，
柯尔松）；
//设置数据源
试试{
setDataSource（getApplicationContext（），trackUri）；
}
捕获（例外e）{
Log.e（“音乐服务”，“错误设置数据源”，e）；
}
player.prepareAsync（）；
}
//设定歌曲
公共空间集松（国际歌曲索引）{
songPosn=songIndex；
}
@凌驾
完成时的公共作废（MediaPlayer mp）{
//检查播放是否已到达曲目的结尾
如果（player.getCurrentPosition（）>0）{
mp.reset（）；
playNext（）；
}
}
@凌驾
公共布尔onError（MediaPlayer mp，int what，int extra）{
Log.v（“音乐播放器”，“播放错误”）；
mp.reset（）；
返回false；
}
@凌驾
已准备好公开作废（MediaPlayer mp）{
//开始播放
mp.start（）；
//通知
Intent notIntent=新的Intent（this，MainActivity.class）；
notIntent.addFlags（Intent.FLAG\u ACTIVITY\u CLEAR\u TOP）；
PendingEvent pendInt=PendingEvent.getActivity（此，0，
notIntent、PendingEvent.FLAG_UPDATE_CURRENT）；
NotificationCompat.Builder=新建NotificationCompat.Builder（此）；
builder.setContentIntent（pendInt）
.setSmallIcon（右可拖动播放）
.setTicker（歌曲标题）
.正在进行（正确）
.setContentTitle（“播放”）
.setContentText（歌曲标题）；
Notification not=builder.build（）；
startForeground（通知您的ID，而不是）；
}
//回放方法
public int getPosn（）{
返回player.getCurrentPosition（）；
}
公共int getDur（）{
返回player.getDuration（）；
}
公共布尔值isPng（）{
返回player.isPlaying（）；
}
public void pausePlayer（）{
player.pause（）；
}
公共无效搜索（int posn）{
player.seekTo（posn）；
}
公开作废go（）{
player.start（）；
}
//跳到上一曲目
公共空间playPrev（）{
松波森；
如果（songPosn=songs.size（））songPosn=0；
}
播放歌曲（）；
}
@凌驾
公共空间{
停止前景（真）；
}
//切换洗牌
公营部门{
如果（shuffle）shuffle=false；
else shuffle=true；
}
}

您的

MusicController

类很可能泄漏您的

主活动。请看这一行：

controller.setMediaPlayer(this);

方向改变后会发生什么？创建了一个新的活动，但是您的控制器可能仍然引用以前的活动，并且不会让垃圾收集器从堆中删除以前的活动，因此可能会导致内存泄漏

为了确保我的假设，您可以安装，这将指出泄漏的根本原因

另请参阅Android中其他类型的内存泄漏以及如何克服它们。
发布相关代码。跟踪泄漏的位置
MainActivity
class.@azizbekian您为什么建议这样做？日志显示，您正在引用来自
MainActivity
的窗口：
MainActivity已泄漏窗口
@azizbekian很抱歉响应延迟。代码张贴。请拿
controller.setMediaPlayer(this);