Java MediaPlayer在异步任务中：已完成但未发布

我编写了一个异步任务，用于播放BGM幻灯片，在开始和暂停时淡入淡出。当幻灯片放映活动开始播放幻灯片时，我启动任务和BGM，并且仅当幻灯片放映活动暂停时才取消任务

BGM在开始时播放一段时间，然后突然停止并循环回到曲目的开头。这项任务甚至还没有被取消。我看到了这个错误：mediaplayer没有发布就完成了。有办法解决这个问题吗

此外，我想淡出和淡入的轨道过渡从结束到开始的轨道。有没有办法听某个音轨点，比如说在音轨结束前5秒，这样我就可以在音轨结束时淡出音轨

提前谢谢

我的async类和logcat的代码如下：

import java.io.File;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

import android.os.AsyncTask;

import android.media.MediaPlayer;
//import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.util.Log;


public class MediaPlayerController extends AsyncTask<String, String, String> {

//*******************

private final static int VOLUME_MIN = 0;

private static double VOLUME_MAX = 100;

private final static float FLOAT_VOLUME_MAX = 1.0f;
private final static float FLOAT_VOLUME_MIN = 0.0f;

private static double iVol;

private static double volChange;

private static String path;

private static MediaPlayer mMediaPlayer;

//*******************

public MediaPlayerController(int vol, String p) {
    super();
    iVol=vol;
    path=p;

    mMediaPlayer=null;

    VOLUME_MAX= iVol;

    volChange=iVol/5;

    Log.d("media player controller Async instance", "iVol "+ iVol + " vol change " + volChange);
}

 @Override
    protected void onPreExecute() {
        super.onPreExecute();
        startSound(path);

    }

    @Override
    protected String doInBackground(String... params) {

       return null;
    }

    @Override
    protected void onProgressUpdate(String... progress) {

    }
    @Override
    protected void onCancelled (){

      stopSound();
    }

    protected void onPostExecute(String file_url) {


    }

//-----------------------------------------------------------




public void startSound(String path){

    mMediaPlayer = new MediaPlayer();

    try {
        File soundFile = new File(path);
        if(soundFile.exists()){

            Log.d("start sound sound file", "exist");

            mMediaPlayer.setDataSource(path);
            mMediaPlayer.prepareAsync();

            //int dur= mMediaPlayer.getDuration();

            //Log.d("start sound mp duration", Integer.toString(dur));

            mMediaPlayer.setOnPreparedListener(new OnPreparedListener() {
                public void onPrepared(MediaPlayer mp) {

                    if (!mMediaPlayer.isPlaying())
                    startFadeInVol(1);  
                }
            }); 

        }else Log.d("start sound sound file", "NOT exist");
    }catch (IllegalArgumentException e1) {
        e1.printStackTrace();
    } catch (IllegalStateException e1) {
        e1.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}


public void stopSound() {
    if ((mMediaPlayer != null) && (mMediaPlayer.isPlaying())){

            if (mMediaPlayer.isPlaying()){
            stopFadeOutVol(1);
            Log.d("stop sound", "stopping");}   
    }       
}


private void updateVolume(double change)
{
    if((mMediaPlayer!=null) && (mMediaPlayer.isPlaying())){
    try{

    iVol =  iVol + change;

    Log.d("update vol", "iVol = "+iVol + " change " + change);

    if (iVol < VOLUME_MIN)
        iVol = VOLUME_MIN;
    else if (iVol > VOLUME_MAX)
        iVol = VOLUME_MAX;


    float fVol = 1 - ((float) Math.log(VOLUME_MAX - iVol) / (float) Math.log(VOLUME_MAX));


    if (fVol < VOLUME_MIN)
        fVol = FLOAT_VOLUME_MIN;
    else if (fVol > FLOAT_VOLUME_MAX)
        fVol = FLOAT_VOLUME_MAX;   

    Log.d("update vol fVol", Float.toString(fVol));

    mMediaPlayer.setVolume(fVol, fVol);

    }catch (Exception e){

        e.printStackTrace();
    }
}
}



public void startFadeInVol(int fadeDuration)
{
    try{

        mMediaPlayer.start();
        mMediaPlayer.setLooping(true);
        Log.d("start fade in vol", "starting");


        iVol = VOLUME_MIN;


    updateVolume(0);


    if(fadeDuration > 0)
    {
        final Timer timer = new Timer(true);
        TimerTask timerTask = new TimerTask() 
        {
            @Override
            public void run() 
            {
                updateVolume(volChange);
                if (iVol >= VOLUME_MAX)
                {
                    timer.cancel();
                    timer.purge();
                }
            }
        };

        int delay = fadeDuration*1000;
        if (delay == 0) delay = 1000;

        timer.schedule(timerTask, 0, delay);
    }
    } catch (Exception e) {
          e.printStackTrace();
      }
}

  private void stopFadeOutVol(int fadeDuration)
  {
      try {
              iVol = VOLUME_MAX;

          updateVolume(0);

          if (fadeDuration > 0)
          {
              final Timer timer = new Timer(true);
              TimerTask timerTask = new TimerTask()
              {
                  @Override
                  public void run()
                  {
                      updateVolume(-volChange);

                      if ((mMediaPlayer!=null) && (iVol <= VOLUME_MIN))
                      {

                          timer.cancel();
                          timer.purge();

                          mMediaPlayer.stop();
                          mMediaPlayer.reset();
                          mMediaPlayer.release();
                          //mMediaPlayer=null;

                          Log.d("stop fade out vol","mp stop");
                      }
                  }
              };

              int delay = fadeDuration*1000;
              if (delay == 0)
                  delay = 1000;

              timer.schedule(timerTask, 0, delay);
          }
      } catch (Exception e) {
          e.printStackTrace();
      }
  }

导入java.io.File；
导入java.io.IOException；
导入java.util.Timer；
导入java.util.TimerTask；
导入android.os.AsyncTask；
导入android.media.MediaPlayer；
//导入android.media.MediaPlayer.OnCompletionListener；
导入android.media.MediaPlayer.OnPreparedListener；
导入android.util.Log；
公共类MediaPlayerController扩展异步任务{
//*******************
私有最终静态整数卷_MIN=0；
专用静态双卷_MAX=100；
私人最终静态浮子体积最大值=1.0f；
专用最终静态浮子体积最小值=0.0f；
专用静态双iVol；
私有静态双变量变化；
私有静态字符串路径；
专用静态媒体播放器；
//*******************
公共媒体播放器控制器（int vol，String p）{
超级（）；
iVol=体积；
path=p；
mmediplayer=null；
体积_MAX=iVol；
volChange=iVol/5；
Log.d（“媒体播放器控制器异步实例”，“iVol”+iVol+“vol change”+volChange”）；
}
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
启动声音（路径）；
}
@凌驾
受保护的字符串doInBackground（字符串…参数）{
返回null；
}
@凌驾
受保护的void onProgressUpdate（字符串…进度）{
}
@凌驾
取消时受保护的空（）{
停止声音（）；
}
受保护的void onPostExecute（字符串文件\u url）{
}
//-----------------------------------------------------------
公共void startSound（字符串路径）{
mMediaPlayer=新媒体播放器（）；
试一试{
文件soundFile=新文件（路径）；
if（soundFile.exists（））{
Log.d（“启动声音文件”、“存在”）；
mmediplayer.setDataSource（路径）；
mMediaPlayer.prepareAsync（）；
//int dur=mmediplayer.getDuration（）；
//Log.d（“开始声音mp持续时间”，Integer.toString（dur））；
mmediplayer.setOnPreparedListener（新的OnPreparedListener（）{
已准备好公开作废（MediaPlayer mp）{
如果（！mmediplayer.isPlaying（））
startFadeInVol（1）；
}
}); 
}else Log.d（“启动声音文件”，“不存在”）；
}捕获（IllegalArgumentException e1）{
e1.printStackTrace（）；
}捕获（非法状态例外e1）{
e1.printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
公共电台{
如果（（mmediplayer！=null）&&（mmediplayer.isPlaying（））{
if（mmediplayer.isPlaying（））{
停止衰减（1）；
Log.d（“停止声音”，“停止”）；}
}       
}
私有void updateVolume（双重更改）
{
如果（（mmediplayer！=null）&&（mmediplayer.isPlaying（））{
试一试{
iVol=iVol+变化；
Log.d（“更新卷”、“iVol=“+iVol+”更改“+change”）；
如果（iVol最大音量）
iVol=体积_最大值；
float fVol=1-（（float）Math.log（VOLUME_MAX-iVol）/（float）Math.log（VOLUME_MAX））；
if（fVol<体积\分钟）
fVol=浮子体积最小值；
否则，如果（fVol>浮动\体积\最大值）
fVol=浮点数\体积\最大值；
Log.d（“更新卷fVol”，Float.toString（fVol））；
设定体积（fVol，fVol）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}
公共无效起始发票（内部发票）
{
试一试{
mmediplayer.start（）；
mmediplayer.setLooping（true）；
Log.d（“开始淡入音量”，“开始”）；
iVol=体积\最小值；
updateVolume（0）；
如果（衰减率>0）
{
最终计时器=新计时器（真）；
TimerTask TimerTask=新TimerTask（）
{
@凌驾
公开募捐
{
updateVolume（volChange）；
如果（iVol>=最大音量）
{
timer.cancel（）；
timer.purge（）；
}
}
};
整数延迟=衰减*1000；
如果（延迟=0）延迟=1000；
定时器调度（timerTask，0，延迟）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
专用void stopFadeOutVol（内部衰减）
{
试一试{
iVol=体积_最大值；
updateVolume（0）；
如果（衰减率>0）
{
最终计时器=新计时器（真）；
TimerTask TimerTask=新TimerTask（）
{
@凌驾
公开募捐
{
updateVolume（-volChange）；
if（（mmediplayer！=null）&&（iVol问题得到解决。感谢其他开发人员的糟糕代码。谢谢大家。
我看到的一些事情：如果
doInBackground（）
方法中没有任何内容，为什么要使用异步任务？。异步任务应该只有
onPreExecute（）
，
doInBackground（）
，
onPostExecute（）
在其中，也可以选择
onProgressUpdate（）
也可以放回
onCompletionListener
并放回那里，停止并释放mediaplayer，如