在后台切断的Android MediaPlayer

Question

我试图实现一个服务，在后台使用mediaplayer类来播放流......无论如何，在某些手机（星系标签和一些LG模型）时，当我的应用程序在背景中时，声音切断时我打开另一个应用程序...为什么这样？下面的一些教程中，我实现这样的服务：

import com.somafm.api.PlayListFile; 
import com.somafm.api.Playlist; 

import android.app.Service; 
import android.content.Context; 
import android.content.Intent; 
import android.media.AudioManager; 
import android.media.MediaPlayer; 
import android.net.Uri; 
import android.os.IBinder; 
import android.os.PowerManager; 
import android.util.Log; 

public class PlayerBackgroundService extends Service { 

    static MediaPlayer.OnPreparedListener prepared_listener; 
    static MediaPlayer.OnBufferingUpdateListener buffering_listener; 
    static MediaPlayer.OnCompletionListener completion_listener; 
    static MediaPlayer.OnErrorListener error_listener; 

    private static Playlist playlist; 
    private static PlayerController player; 
    private static StreamProxy proxy; 
    private static MediaPlayer mp = new MediaPlayer(); 

    static boolean canPlay; 
    static boolean clean; 
    static boolean cancelRequest; 
    static boolean buffering; 
    static boolean isPlaying; 

    private static PowerManager.WakeLock powerLock; 

    @Override 
    public IBinder onBind(Intent intent) { 
     return null; 
    } 

    @Override 
    public void onCreate() 
    { 
     super.onCreate(); 
     init(); 
    } 

    public void init() 
    { 
     PowerManager pM = (PowerManager) getSystemService(Context.POWER_SERVICE); 
     powerLock = pM.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Prevent sleeping"); 
     powerLock.acquire(); 

     prepared_listener = new MediaPlayer.OnPreparedListener() { 

      @Override 
      public void onPrepared(MediaPlayer mp) { 
       canPlay = true; 
       clean = true; 
      } 
     }; 

     error_listener = new MediaPlayer.OnErrorListener() { 

      @Override 
      public boolean onError(MediaPlayer mp, int what, int extra) { 
       Log.i("!!MEDIAERROR!!", "WHAT " + what + " - " + extra); 
       canPlay = true; 
       clean = false; 
       isPlaying = false; 
       return true; 
      } 
     }; 

     buffering_listener = new MediaPlayer.OnBufferingUpdateListener() { 
      @Override 
      public void onBufferingUpdate(MediaPlayer mp, int percent) { 
       Log.i("BUFFERING", "" + percent); 
       if(percent > 0) 
       { 
        if(mp.isPlaying() && !buffering) 
        { 
         player.notifyAllBuffering(); 
         buffering = true; 
        } 
       } 
       else 
       { 
        if(buffering) 
        { 
         player.notifyAllNotBuffering(); 
         buffering = false; 
        } 
       } 
      } 
     }; 

     completion_listener = new MediaPlayer.OnCompletionListener() { 

      @Override 
      public void onCompletion(MediaPlayer mp) { 
       //stop(); 
       Log.i("COMPLETED", "COMPLETED"); 
      } 
     }; 

    } 

    public synchronized static void start(){ 
     mp.start(); 
     isPlaying = true; 
    } 

    public synchronized static void prepare(){ 

     canPlay = false; 
     clean = true; 

     proxy = new StreamProxy(); 
     proxy.init(); 
     proxy.start(); 

     if (playlist == null) 
     { 
      clean = false; 
      proxy.stop(); 
      return; 
     } 

     int i = 0; 

     String proxyUrl = ""; 

     playlist.fetchContent(); 
     PlayListFile[] urlsToPlay = playlist.getFiles(); 

     if (urlsToPlay == null) 
     { 
      clean = false; 
      proxy.stop(); 
      return; 
     } 

     if (urlsToPlay.length == 0) 
     { 
      clean = false; 
      proxy.stop(); 
      return; 
     } 

     do{ 
      try{ 

       proxyUrl = String.format("http://127.0.0.1:%d/%s", proxy 
         .getPort(), Uri.parse(urlsToPlay[i].getUrl())); 
       i++; 
       Log.i("Trying link", "" + urlsToPlay.length); 
       mp = new MediaPlayer(); 
       mp.setOnPreparedListener(prepared_listener); 
       mp.setOnBufferingUpdateListener(buffering_listener); 
       mp.setOnErrorListener(error_listener); 
       mp.setOnCompletionListener(completion_listener); 
       mp.setDataSource(proxyUrl); 
       mp.setAudioStreamType(AudioManager.STREAM_MUSIC); 
       mp.prepare(); 


      }catch(Exception ex) 
      { 
       clean = false;     
       ex.printStackTrace(); 
      } 

      if(cancelRequest == true) 
      { 
       clean = true; 
       return; 
      } 

      if(i >= urlsToPlay.length) 
       canPlay = true; 

     }while(canPlay == false); 

     if(clean == false && proxy != null) 
      proxy.stop(); 

    } 


    public synchronized static void stop() { 
     if(proxy != null) 
      proxy.stop(); 
     if(mp != null) 
      mp.stop(); 
     isPlaying = false; 
    } 

    public synchronized static void loadPlaylist(Playlist playlist) { 
     PlayerBackgroundService.playlist = playlist; 
    } 

    public synchronized static void registerPlayer(PlayerController player) { 
     PlayerBackgroundService.player = player; 
    } 

    @Override 
    public void onDestroy() { 
     super.onDestroy(); 

     if (powerLock != null && powerLock.isHeld()) 
      powerLock.release(); 
    } 


} 

并以这种方式启动它：

this.startService(new Intent(appcontext, PlayerBackgroundService.class)); 

也许我的课是错的..你可以帮助我吗？

在此先感谢

Answer 1

您需要手动停止和恢复已在媒体播放器使用的暂停被播放的音频和恢复活动的方法，看看这个，

@Override 
protected void onResume() { 
    super.onResume(); 
    if (mediaPlayer != null) { 
     mediaPlayer.start(); 
    } 
} 

protected void onPause() { 
    super.onPause(); 
    if (mediaPlayer != null) { 
     mediaPlayer.pause(); 
     if (isFinishing()) { 
      mediaPlayer.stop(); 
      mediaPlayer.release(); 
     } 
    }