一、前言
MediaPlayer是Android自帶的一個多媒體播放類，可以播放音視頻流或者本地音視頻文件。MediaPlayer方法的調(diào)用需要在一定的狀態(tài)下，下圖是一個MediaPlayer對象被支持的播放控制操作驅(qū)動的聲明周期和狀態(tài)。其中，橢圓代表MediaPlayer可能駐留的狀態(tài)，弧線表示驅(qū)動MediaPlayer在各個狀態(tài)之間遷移的播放控制操作。這里有兩種類型的弧線。由單箭頭開始的弧線代表同步方法調(diào)用，而以雙箭頭開頭的弧線代表異步方法調(diào)用。圖片介紹來源于官方文。
MediaPlayer的聲明周期和狀態(tài)
詳細介紹可通過Android -- 多媒體播放之MediaPlayer基礎(chǔ)簡介了解更多
二、播放網(wǎng)絡(luò)音頻
現(xiàn)在寫一個支持本地緩存的網(wǎng)絡(luò)音頻播放器,并添加了喚醒鎖、WiFi鎖和音頻焦點等功能。
1、自定義MediaPlayer
直接通過MediaPlayer獲取播放狀態(tài)有時不夠準確，所以自定義ManagedMediaPlayer繼承MediaPlayer，拓展MediaPlayer的功能，控制播放狀態(tài)
public class ManagedMediaPlayer extends MediaPlayer implements MediaPlayer.OnCompletionListener {
public enum Status {
IDLE, INITIALIZED, STARTED, PAUSED, STOPPED, COMPLETED
}
private Status mState;
private OnCompletionListener mOnCompletionListener;
public ManagedMediaPlayer() {
super();
mState = Status.IDLE;
super.setOnCompletionListener(this);
}
@Override
public void reset() {
super.reset();
mState = Status.IDLE;
}
@Override
public void setDataSource(String path) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
super.setDataSource(path);
mState = Status.INITIALIZED;
}
@Override
public void start() {
super.start();
mState = Status.STARTED;
}
@Override
public void setOnCompletionListener(OnCompletionListener listener) {
this.mOnCompletionListener = listener;
}
@Override
public void onCompletion(MediaPlayer mp) {
mState = Status.COMPLETED;
if (mOnCompletionListener != null) {
mOnCompletionListener.onCompletion(mp);
}
}
@Override
public void stop() throws IllegalStateException {
super.stop();
mState = Status.STOPPED;
}
@Override
public void pause() throws IllegalStateException {
super.pause();
mState = Status.PAUSED;
}
public void setState(Status mState) {
this.mState = mState;
}
public Status getState() {
return mState;
}
public boolean isComplete() {
return mState == Status.COMPLETED;
}
}
2、喚醒鎖、WiFi鎖
app在長時間后臺運行時，手機有可能會進入休眠，這是CUP和WiFi可能會停止運行，影響到app的正常運行，所以我們需要加入喚醒鎖和WiFi鎖保證我們在后臺長時間播放音頻的穩(wěn)定。
初始化時MediaPlayer時使用喚醒鎖并初始化WiFi鎖
// 使用喚醒鎖
mMediaPlayer.setWakeMode(MyApplication.getContext(), PowerManager.PARTIAL_WAKE_LOCK);
// 初始化wifi鎖
WifiManager.WifiLock wifiLock = ((WifiManager) MyApplication.getContext().getApplicationContext().getSystemService(Context.WIFI_SERVICE)).createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock");
在開始播放的時候啟用WiFi鎖
// 啟用wifi鎖
wifiLock.acquire();
在暫定和釋放資源的時候關(guān)閉WiFi鎖
// 關(guān)閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}
3、音頻焦點
Android系統(tǒng)是一個多任務(wù)操作系統(tǒng)，因此同一時刻允許許多任務(wù)同時工作。但是這對音頻類應(yīng)用來說是個挑戰(zhàn)，因為如果多個音頻同時播放的話，很多情況下用戶體驗會相當(dāng)?shù)牟睢．?dāng)你需要播放音樂或者發(fā)送一個通知的時候，你可以去要求獲得音頻焦點。一旦獲得，就可以自由的使用音頻輸出設(shè)備。但是同時它也在時時刻刻的監(jiān)聽著音頻焦點的變化。當(dāng)音頻焦點變化時，你需要去合適的處理你的音頻輸出。
自定義AudioFocusManager實現(xiàn)音頻焦點變化監(jiān)聽
public class AudioFocusManager implements AudioManager.OnAudioFocusChangeListener{
private static final String TAG = "AudioFocusManager";
private AudioManager audioManager;
private boolean isPausedByFocusLossTransient;
public AudioFocusManager(Context context) {
audioManager = (AudioManager) context.getSystemService(AUDIO_SERVICE);
}
public boolean requestAudioFocus() {
return audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
== AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
}
public void abandonAudioFocus() {
audioManager.abandonAudioFocus(this);
}
@Override
public void onAudioFocusChange(int focusChange) {
switch (focusChange) {
// 重新獲得焦點
case AudioManager.AUDIOFOCUS_GAIN:
if (isPausedByFocusLossTransient) {
// 通話結(jié)束，恢復(fù)播放
AudioPlayer.getInstance().resume();
}
// 恢復(fù)音量
AudioPlayer.getInstance().getMediaPlayer().setVolume(1f, 1f);
isPausedByFocusLossTransient = false;
Log.d(TAG, "重新獲得焦點");
break;
// 永久丟失焦點，如被其他播放器搶占
case AudioManager.AUDIOFOCUS_LOSS:
PlayerService.stopPlayerService();
abandonAudioFocus();
Log.d(TAG, "永久丟失焦點，如被其他播放器搶占");
break;
// 短暫丟失焦點，如來電
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
AudioPlayer.getInstance().pause();
isPausedByFocusLossTransient = true;
Log.d(TAG, "短暫丟失焦點，如來電");
break;
// 瞬間丟失焦點，如通知
case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
// 音量減小為一半
AudioPlayer.getInstance().getMediaPlayer().setVolume(0.5f, 0.5f);
Log.d(TAG, "瞬間丟失焦點，如通知");
break;
default:
break;
}
}
}
在初始化MediaPlayer時初始化AudioFocusManager
// 初始化音頻焦點管理器
AudioFocusManager audioFocusManager = new AudioFocusManager(MyApplication.getContext());
在開始播放的時候獲取音頻焦點
// 獲取音頻焦點
if (!audioFocusManager.requestAudioFocus()) {
Log.e(TAG, "獲取音頻焦點失敗");
}
在暫定、停止和釋放資源的時候取消音頻焦點
// 取消音頻焦點
if (audioFocusManager != null) {
audioFocusManager.abandonAudioFocus();
}
4、緩存
這里使用了AndroidVideoCache做本地緩存。
添加AndroidVideoCache依賴
dependencies {
implementation'com.danikula:videocache:2.7.0'
}
自定義緩存文件命名規(guī)則
public class CacheFileNameGenerator implements FileNameGenerator {
private static final String TAG = "CacheFileNameGenerator";
/**
* @param url
* @return
*/
@Override
public String generate(String url) {
Uri uri = Uri.parse(url);
List<String> pathSegList = uri.getPathSegments();
String path = null;
if (pathSegList != null && pathSegList.size() > 0) {
path = pathSegList.get(pathSegList.size() - 1);
} else {
path = url;
}
Log.d(TAG, "generate return " + path);
return path;
}
}
創(chuàng)建單例的AndroidVideoCache實例的方法
public class HttpProxyCacheUtil {
private static HttpProxyCacheServer audioProxy;
public static HttpProxyCacheServer getAudioProxy() {
if (audioProxy== null) {
audioProxy= new HttpProxyCacheServer.Builder(MyApplication.getContext())
.cacheDirectory(CachesUtil.getMediaCacheFile(CachesUtil.AUDIO))
.maxCacheSize(1024 * 1024 * 1024) // 緩存大小
.fileNameGenerator(new CacheFileNameGenerator())
.build();
}
return audioProxy;
}
}
使用AndroidVideoCache進行緩存，只要將url經(jīng)過HttpProxyCacheServer轉(zhuǎn)化就可以了，AndroidVideoCache會處理緩存
String url = "XXXXXXXXXXX";
HttpProxyCacheServer proxy = HttpProxyCacheUtil.getAudioProxy()
url = proxy.getProxyUrl(url);
5、UI響應(yīng)
監(jiān)聽播放時不同的狀態(tài)，并通過廣播的形式通知UI做出響應(yīng)。
創(chuàng)建一個基類的BasePlayReceiver，接收初始化信息完成、資源準備完成、資源播放完成、播放狀態(tài)改變、緩沖進度和播放錯誤等廣播
public abstract class BasePlayReceiver extends BroadcastReceiver {
public static String ACTION = "com.example.android.myapplication.PLAY_RECEIVER";
public static String EXTRA_TYPE = "type";
public static String TYPE_ON_INIT_SOURCE = "onInitSource";
public static String EXTRA_SOURCE = "source";
public static String TYPE_ON_PREPARED = "onPrepared";
public static String TYPE_ON_COMPLETION = "onCompletion";
public static String TYPE_ON_PLAY_STATUS = "onPlayStatus";
public static String TYPE_ON_BUFFERING_UPDATE = "onBufferingUpdate";
public static String EXTRA_PERCENT = "percent";
public static String TYPE_ON_ERROR = "onError";
public static String EXTRA_WHAT = "what";
public static String EXTRA_EXTRA = "extra";
public static void registerReceiver(Context context, BasePlayReceiver basePlayReceiver) {
IntentFilter filter = new IntentFilter();
filter.addAction(BasePlayReceiver.ACTION);
//注冊
context.registerReceiver(basePlayReceiver, filter);
}
public static void unregisterReceiver(Context context, BasePlayReceiver basePlayReceiver) {
if (basePlayReceiver != null) {
context.unregisterReceiver(basePlayReceiver);
}
}
public static void sendBroadcastInitSource(Context context, AlbumProgramItemBean song) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_INIT_SOURCE);
intent.putExtra(BasePlayReceiver.EXTRA_SOURCE, song);
context.sendBroadcast(intent);
}
public static void sendBroadcastPrepared(Context context) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_PREPARED);
context.sendBroadcast(intent);
}
public static void sendBroadcastCompletion(Context context) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_COMPLETION);
context.sendBroadcast(intent);
}
public static void sendBroadcastPlayStatus(Context context) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_PLAY_STATUS);
context.sendBroadcast(intent);
}
public static void sendBroadcastBufferingUpdate(Context context, int percent) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_BUFFERING_UPDATE);
intent.putExtra(BasePlayReceiver.EXTRA_PERCENT, percent);
context.sendBroadcast(intent);
}
public static void sendBroadcastError(Context context, int what, int extra) {
Intent intent = new Intent();
intent.setAction(BasePlayReceiver.ACTION);
intent.putExtra(BasePlayReceiver.EXTRA_TYPE, TYPE_ON_ERROR);
intent.putExtra(BasePlayReceiver.EXTRA_WHAT, what);
intent.putExtra(BasePlayReceiver.EXTRA_EXTRA, extra);
context.sendBroadcast(intent);
}
@Override
public void onReceive(Context context, Intent intent) {
if (!BasePlayReceiver.ACTION.equals(intent.getAction()) || intent.getExtras() == null) {
return;
}
Bundle bundle = intent.getExtras();
String type = bundle.getString(EXTRA_TYPE);
if (TYPE_ON_INIT_SOURCE.equals(type)) {
onInitSource((AlbumProgramItemBean) bundle.getParcelable(EXTRA_SOURCE));
} else if (TYPE_ON_PREPARED.equals(type)) {
onPrepared();
} else if (TYPE_ON_COMPLETION.equals(type)) {
onCompletion();
} else if (TYPE_ON_PLAY_STATUS.equals(type)) {
onPlayStatus();
} else if (TYPE_ON_BUFFERING_UPDATE.equals(type)) {
onBufferingUpdate(bundle.getInt(EXTRA_PERCENT));
} else if (TYPE_ON_ERROR.equals(type)) {
onError(bundle.getInt(EXTRA_WHAT), bundle.getInt(EXTRA_EXTRA));
}
}
/**
* 初始化信息
*
* @param source
*/
protected abstract void onInitSource(AlbumProgramItemBean source);
/**
* 資源準備完成
*/
protected abstract void onPrepared();
/**
* 資源播放完成
*/
protected abstract void onCompletion();
/**
* 播放狀態(tài)的改變
*/
protected abstract void onPlayStatus();
/**
* 緩存進度
*
* @param percent
*/
protected abstract void onBufferingUpdate(int percent);
/**
* 播放錯誤
*
* @param what
* @param extra
*/
protected abstract void onError(int what, int extra);
}
在需要改變UI的地方，繼承BasePlayReceiver，實現(xiàn)其中的方法并動態(tài)注冊即可。
6、播放控制類
新建單例的音頻播放控制類AudioPlayer，方便對音頻進行控制，并在操作音頻之前都做了狀態(tài)判斷，盡可能的減少錯誤的發(fā)生。在AudioPlayer中可設(shè)置播放模式（順序、列表循環(huán)、隨機和單曲循環(huán)），播放，暫停，上下曲，seekTo，停止,獲取播放總時間和獲取當(dāng)前播放進度等功能，并保存全局的播放列表和當(dāng)前播放的音頻，方便獲取相關(guān)信息。
public class AudioPlayer implements MediaPlayer.OnCompletionListener, MediaPlayer.OnPreparedListener, MediaPlayer.OnBufferingUpdateListener, MediaPlayer.OnErrorListener {
private static final String TAG = "AudioPlayer";
/**
* 播放方式
*/
public enum PlayMode {
/**
* 順序
*/
ORDER,
/**
* 列表循環(huán)
*/
LOOP,
/**
* 隨機
*/
RANDOM,
/**
* 單曲循環(huán)
*/
REPEAT
}
private ManagedMediaPlayer mMediaPlayer;
private List<AlbumProgramItemBean> mQueue;
private int mQueueIndex;
private PlayMode mPlayMode = PlayMode.ORDER;
private AlbumProgramItemBean nowPlaying;
private WifiManager.WifiLock wifiLock;
private AudioFocusManager audioFocusManager;
private HttpProxyCacheServer proxy;
private static class SingletonHolder {
private static AudioPlayer instance = new AudioPlayer();
}
public static AudioPlayer getInstance() {
return SingletonHolder.instance;
}
@Override
public void onCompletion(MediaPlayer mp) {
BasePlayReceiver.sendBroadcastCompletion(MyApplication.getContext());
}
@Override
public void onPrepared(MediaPlayer mp) {
start();
BasePlayReceiver.sendBroadcastPrepared(MyApplication.getContext());
}
@Override
public void onBufferingUpdate(MediaPlayer mp, int percent) {
BasePlayReceiver.sendBroadcastBufferingUpdate(MyApplication.getContext(), percent);
}
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
Log.e(TAG, "MediaPlayer onError what " + what + " extra " + extra);
release();
next();
BasePlayReceiver.sendBroadcastError(MyApplication.getContext(), what, extra);
return false;
}
public void init() {
mMediaPlayer = new ManagedMediaPlayer();
// 使用喚醒鎖
mMediaPlayer.setWakeMode(MyApplication.getContext(), PowerManager.PARTIAL_WAKE_LOCK);
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mMediaPlayer.setOnCompletionListener(this);
mMediaPlayer.setOnPreparedListener(this);
mMediaPlayer.setOnBufferingUpdateListener(this);
mMediaPlayer.setOnErrorListener(this);
// 初始化wifi鎖
wifiLock = ((WifiManager) MyApplication.getContext().getApplicationContext().getSystemService(Context.WIFI_SERVICE)).createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock");
// 初始化音頻焦點管理器
audioFocusManager = new AudioFocusManager(MyApplication.getContext());
// 初始化AndroidVideoCache
proxy = HttpProxyCacheUtil.getAudioProxy();
}
public void setPlayIndex(int index) {
this.mQueueIndex = index;
}
public void setQueue(List<AlbumProgramItemBean> mQueue) {
this.mQueue = mQueue;
}
public void setQueueAndIndex(List<AlbumProgramItemBean> mQueue, int mQueueIndex) {
this.mQueue = mQueue;
this.mQueueIndex = mQueueIndex;
}
private void play(AlbumProgramItemBean source) {
if (source == null) {
Log.e(TAG, "沒有可用資源");
return;
}
if (mMediaPlayer == null) {
init();
}
if (getStatus() == ManagedMediaPlayer.Status.INITIALIZED) {
Log.e(TAG, "正在準備上一個資源，請稍候");
return;
}
// 更新播放器狀態(tài)
mMediaPlayer.reset();
nowPlaying = source;
// 更新Notification
Notifier.getInstance().showPlayInfo(source);
// 向MainActivity發(fā)送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 發(fā)送初始化資源信息的廣告
BasePlayReceiver.sendBroadcastInitSource(MyApplication.getContext(), source);
// 獲取音頻地址（音頻地址一般私有）
Call<BaseCallBackVo<String>> call = HttpClientFactory.getAppApiClientInstance().getAlbumAddress(source.getId());
call.enqueue(new Callback<BaseCallBackVo<String>>() {
@Override
public void onResponse(Call<BaseCallBackVo<String>> call, Response<BaseCallBackVo<String>> response) {
if (response.code() == 200 && response.body() != null) {
if (response.body().getStatus() == 200) {
String url = response.body().getData();
url = proxy.getProxyUrl(url);
play(url);
}
}
}
@Override
public void onFailure(Call<BaseCallBackVo<String>> call, Throwable t) {
BasePlayReceiver.sendBroadcastPrepared(MyApplication.getContext());
}
});
}
private void play(String dataSource) {
// mMediaPlayer.reset();
try {
mMediaPlayer.setDataSource(dataSource);
mMediaPlayer.prepareAsync();
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "該資源無法播放");
BasePlayReceiver.sendBroadcastPrepared(MyApplication.getContext());
}
}
private void start() {
// 獲取音頻焦點
if (!audioFocusManager.requestAudioFocus()) {
Log.e(TAG, "獲取音頻焦點失敗");
}
mMediaPlayer.start();
// 啟用wifi鎖
wifiLock.acquire();
// 更新notification
Notifier.getInstance().showPlayInfo(nowPlaying);
// 向MainActivity發(fā)送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 發(fā)送播放狀態(tài)的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
}
public void pause() {
if (getStatus() == ManagedMediaPlayer.Status.STARTED) {
mMediaPlayer.pause();
// 關(guān)閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}
// 發(fā)送播放狀態(tài)的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
// 更新notification
Notifier.getInstance().showPlayInfo(nowPlaying);
// 向MainActivity發(fā)送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 取消音頻焦點
if (audioFocusManager != null) {
audioFocusManager.abandonAudioFocus();
}
}
}
public void resume() {
if (getStatus() == ManagedMediaPlayer.Status.PAUSED) {
start();
}
}
public void stop() {
if (getStatus() == ManagedMediaPlayer.Status.STARTED
|| getStatus() == ManagedMediaPlayer.Status.PAUSED
|| getStatus() == ManagedMediaPlayer.Status.COMPLETED) {
mMediaPlayer.stop();
// 發(fā)送播放狀態(tài)的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
// 更新notification
Notifier.getInstance().showPlayInfo(nowPlaying);
// 向MainActivity發(fā)送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 取消音頻焦點
if (audioFocusManager != null) {
audioFocusManager.abandonAudioFocus();
}
}
}
public void release() {
if (mMediaPlayer == null) {
return;
}
nowPlaying = null;
Log.d(TAG, "release");
mMediaPlayer.release();
mMediaPlayer = null;
// 取消音頻焦點
if (audioFocusManager != null) {
audioFocusManager.abandonAudioFocus();
}
// 關(guān)閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}
wifiLock = null;
audioFocusManager = null;
proxy = null;
// 向MainActivity發(fā)送EventBus
EventBus.getDefault().post(new MainActivityEvent());
}
public void seekTo(int msec) {
if (getStatus() == ManagedMediaPlayer.Status.STARTED
|| getStatus() == ManagedMediaPlayer.Status.PAUSED
|| getStatus() == ManagedMediaPlayer.Status.COMPLETED) {
mMediaPlayer.seekTo(msec);
}
}
/**
* 播放
*/
public void play() {
AlbumProgramItemBean albumProgramItemBean = getPlaying(mQueueIndex);
play(albumProgramItemBean);
}
public void next() {
AlbumProgramItemBean albumProgramItemBean = getNextPlaying();
play(albumProgramItemBean);
}
public void previous() {
AlbumProgramItemBean albumProgramItemBean = getPreviousPlaying();
play(albumProgramItemBean);
}
public AlbumProgramItemBean getNowPlaying() {
if (nowPlaying != null) {
return nowPlaying;
} else {
return getPlaying(mQueueIndex);
}
}
public int getCurrentPosition() {
if (getStatus() == ManagedMediaPlayer.Status.STARTED
|| getStatus() == ManagedMediaPlayer.Status.PAUSED) {
return mMediaPlayer.getCurrentPosition();
}
return 0;
}
public int getDuration() {
if (getStatus() == ManagedMediaPlayer.Status.STARTED
|| getStatus() == ManagedMediaPlayer.Status.PAUSED) {
return mMediaPlayer.getDuration();
}
return 0;
}
public ManagedMediaPlayer.Status getStatus() {
if (mMediaPlayer != null) {
return mMediaPlayer.getState();
} else {
return ManagedMediaPlayer.Status.STOPPED;
}
}
public MediaPlayer getMediaPlayer() {
return mMediaPlayer;
}
public PlayMode getPlayMode() {
return mPlayMode;
}
public void setPlayMode(PlayMode playMode) {
mPlayMode = playMode;
}
public int getQueueIndex() {
return mQueueIndex;
}
public List<AlbumProgramItemBean> getQueue() {
return mQueue == null ? new ArrayList<AlbumProgramItemBean>() : mQueue;
}
private AlbumProgramItemBean getNextPlaying() {
switch (mPlayMode) {
case ORDER:
mQueueIndex = mQueueIndex + 1;
return getPlaying(mQueueIndex);
case LOOP:
mQueueIndex = (mQueueIndex + 1) % mQueue.size();
return getPlaying(mQueueIndex);
case RANDOM:
mQueueIndex = new Random().nextInt(mQueue.size()) % mQueue.size();
return getPlaying(mQueueIndex);
case REPEAT:
return getPlaying(mQueueIndex);
default:
break;
}
return null;
}
private AlbumProgramItemBean getPreviousPlaying() {
switch (mPlayMode) {
case ORDER:
mQueueIndex = mQueueIndex - 1;
return getPlaying(mQueueIndex);
case LOOP:
mQueueIndex = (mQueueIndex + mQueue.size() - 1) % mQueue.size();
return getPlaying(mQueueIndex);
case RANDOM:
mQueueIndex = new Random().nextInt(mQueue.size()) % mQueue.size();
return getPlaying(mQueueIndex);
case REPEAT:
return getPlaying(mQueueIndex);
default:
break;
}
return null;
}
private AlbumProgramItemBean getPlaying(int index) {
if (mQueue != null && !mQueue.isEmpty() && index >= 0 && index < mQueue.size()) {
return mQueue.get(index);
} else {
return null;
}
}
}
7、通知欄
創(chuàng)建通知欄
public class Notifier {
public static final String CHANNEL_ID = "channel_id_audio";
public static final String CHANNEL_NAME = "channel_name_audio";
public static final String CHANNEL_ID_DEFAULT = "channel_id_default";
public static final String EXTRA_NOTIFICATION = "com.sktcm.app.doctor.utils.audio.notification_dark";
private static final int NOTIFICATION_ID = 0x111;
private PlayerService playerService;
private NotificationManager notificationManager;
private boolean isDark;
private String packageName;
public static Notifier getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static Notifier instance = new Notifier();
}
private Notifier() {
}
public void init(PlayerService playerService) {
this.playerService = playerService;
this.notificationManager = (NotificationManager) playerService.getSystemService(NOTIFICATION_SERVICE);
// 前臺服務(wù)
this.playerService.startForeground(NOTIFICATION_ID, buildNotification(playerService, AudioPlayer.getInstance().getNowPlaying()));
this.packageName = MyApplication.getContext().getPackageName();
this.isDark = isDarkNotificationBar(playerService);
}
public void stopForeground() {
this.playerService.stopForeground(true);
}
public void showPlayInfo(AlbumProgramItemBean source) {
this.notificationManager.notify(NOTIFICATION_ID, buildNotification(playerService, source));
}
private Notification buildNotification(Context context, AlbumProgramItemBean source) {
Intent intent = context.getPackageManager().getLaunchIntentForPackage(packageName);
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
//適配安卓8.0的消息渠道
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW);
channel.enableLights(false);
channel.enableVibration(false);
notificationManager.createNotificationChannel(channel);
}
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID)
.setContentIntent(pendingIntent)
.setSmallIcon(R.mipmap.ic_launcher)
.setContent(getRemoteViews(playerService, source));
return builder.build();
}
private RemoteViews getRemoteViews(Context context, AlbumProgramItemBean source) {
int layoutId = isDark ? R.layout.notification_dark : R.layout.notification_light;
final RemoteViews remoteViews = new RemoteViews(context.getPackageName(), layoutId);
if (source == null) {
remoteViews.setTextViewText(R.id.tvTitle, "資源名稱");
remoteViews.setViewVisibility(R.id.tvSubtitle, View.GONE);
remoteViews.setViewVisibility(R.id.btnPlay, View.GONE);
remoteViews.setViewVisibility(R.id.btnNext, View.GONE);
remoteViews.setImageViewResource(R.id.ivIcon, R.mipmap.ic_launcher);
} else {
remoteViews.setTextViewText(R.id.tvTitle, source.getName());
remoteViews.setViewVisibility(R.id.btnPlay, View.VISIBLE);
remoteViews.setViewVisibility(R.id.btnNext, View.VISIBLE);
remoteViews.setImageViewResource(R.id.btnPlay, getPlayIconRes());
if (Variables.nowPlayingAlbumData != null && !TextUtils.isEmpty(Variables.nowPlayingAlbumData.getName())) {
remoteViews.setViewVisibility(R.id.tvSubtitle, View.VISIBLE);
remoteViews.setTextViewText(R.id.tvSubtitle, Variables.nowPlayingAlbumData.getName());
Glide.with(context).load(Variables.nowPlayingAlbumData.getHead()).asBitmap().placeholder(R.mipmap.ic_launcher)
.error(R.drawable.icon_img_err).into(new SimpleTarget<Bitmap>(128, 128) {
@Override
public void onResourceReady(Bitmap bitmap, GlideAnimation glideAnimation) {
remoteViews.setImageViewBitmap(R.id.ivIcon, bitmap);
}
});
} else {
remoteViews.setViewVisibility(R.id.tvSubtitle, View.GONE);
remoteViews.setImageViewResource(R.id.ivIcon, R.mipmap.ic_launcher);
}
Intent playIntent = new Intent(NotificationReceiver.ACTION_STATUS_BAR);
playIntent.putExtra(NotificationReceiver.EXTRA, NotificationReceiver.EXTRA_PLAY);
PendingIntent playPendingIntent = PendingIntent.getBroadcast(context, 1, playIntent, PendingIntent.FLAG_UPDATE_CURRENT);
remoteViews.setOnClickPendingIntent(R.id.btnPlay, playPendingIntent);
Intent nextIntent = new Intent(NotificationReceiver.ACTION_STATUS_BAR);
nextIntent.putExtra(NotificationReceiver.EXTRA, NotificationReceiver.EXTRA_NEXT);
PendingIntent nextPendingIntent = PendingIntent.getBroadcast(context, 2, nextIntent, PendingIntent.FLAG_UPDATE_CURRENT);
remoteViews.setOnClickPendingIntent(R.id.btnNext, nextPendingIntent);
}
return remoteViews;
}
private int getPlayIconRes() {
if (AudioPlayer.getInstance().getStatus() == ManagedMediaPlayer.Status.STARTED) {
return getStartIcon();
} else {
return getPauseIcon();
}
}
private int getStartIcon() {
return isDark ? R.drawable.selector_play : R.drawable.selector_play_light;
}
private int getPauseIcon() {
return isDark ? R.drawable.selector_pause : R.drawable.selector_pause_light;
}
/**********************************************************************************************/
private static final double COLOR_THRESHOLD = 180.0;
private String DUMMY_TITLE = "DUMMY_TITLE";
private int titleColor = 0;
/**
* 判斷是否Notification背景是否為黑色
*
* @param context
* @return
*/
public boolean isDarkNotificationBar(Context context) {
return !isColorSimilar(Color.BLACK, getNotificationTitleColor(context));
}
/**
* 獲取Notification 標題的顏色
*
* @param context
* @return
*/
private int getNotificationTitleColor(Context context) {
int color = 0;
if (context instanceof AppCompatActivity) {
color = getNotificationColorCompat(context);
} else {
color = getNotificationColorInternal(context);
}
return color;
}
/**
* 判斷顏色是否相似
*
* @param baseColor
* @param color
* @return
*/
public boolean isColorSimilar(int baseColor, int color) {
int simpleBaseColor = baseColor | 0xff000000;
int simpleColor = color | 0xff000000;
int baseRed = Color.red(simpleBaseColor) - Color.red(simpleColor);
int baseGreen = Color.green(simpleBaseColor) - Color.green(simpleColor);
int baseBlue = Color.blue(simpleBaseColor) - Color.blue(simpleColor);
double value = Math.sqrt(baseRed * baseRed + baseGreen * baseGreen + baseBlue * baseBlue);
return value < COLOR_THRESHOLD;
}
/**
* 獲取標題顏色
*
* @param context
* @return
*/
private int getNotificationColorInternal(Context context) {
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID_DEFAULT);
builder.setContentTitle(DUMMY_TITLE);
Notification notification = builder.build();
RemoteViews contentView = notification.contentView;
if (contentView != null) {
ViewGroup notificationRoot = (ViewGroup) contentView.apply(context, new FrameLayout(context));
TextView title = (TextView) notificationRoot.findViewById(android.R.id.title);
if (title == null) {
//如果ROM廠商更改了默認的id
iteratorView(notificationRoot, new Filter() {
@Override
public void filter(View view) {
if (view instanceof TextView) {
TextView textView = (TextView) view;
if (DUMMY_TITLE.equals(textView.getText().toString())) {
titleColor = textView.getCurrentTextColor();
}
}
}
});
return titleColor == 0 ? Color.WHITE : titleColor;
} else {
return title.getCurrentTextColor();
}
} else {
return Color.BLACK;
}
}
private int getNotificationColorCompat(Context context) {
NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
Notification notification = builder.build();
int layoutId = notification.contentView.getLayoutId();
ViewGroup notificationRoot = (ViewGroup) LayoutInflater.from(context).inflate(layoutId, null);
TextView title = (TextView) notificationRoot.findViewById(android.R.id.title);
if (title == null) {
final List<TextView> textViews = new ArrayList<>();
iteratorView(notificationRoot, new Filter() {
@Override
public void filter(View view) {
if (view instanceof TextView) {
textViews.add((TextView) view);
}
}
});
float minTextSize = Integer.MIN_VALUE;
int index = 0;
for (int i = 0, j = textViews.size(); i < j; i++) {
float currentSize = textViews.get(i).getTextSize();
if (currentSize > minTextSize) {
minTextSize = currentSize;
index = i;
}
}
textViews.get(index).setText(DUMMY_TITLE);
return textViews.get(index).getCurrentTextColor();
} else {
return title.getCurrentTextColor();
}
}
private void iteratorView(View view, Filter filter) {
if (view == null || filter == null) {
return;
}
filter.filter(view);
if (view instanceof ViewGroup) {
ViewGroup container = (ViewGroup) view;
for (int i = 0, j = container.getChildCount(); i < j; i++) {
View child = container.getChildAt(i);
iteratorView(child, filter);
}
}
}
interface Filter {
void filter(View view);
}
}
操作通知欄的按鈕時發(fā)送廣播，自定義NotificationReceiver,并靜態(tài)注冊，在NotificationReceiver中控制音頻播放
public class NotificationReceiver extends BroadcastReceiver {
public static final String ACTION_STATUS_BAR = "com.sktcm.app.doctor.utils.audio.NOTIFICATION_ACTIONS";
public static final String EXTRA = "extra";
public static final String EXTRA_PLAY = "play_pause";
public static final String EXTRA_NEXT= "play_next";
@Override
public void onReceive(Context context, Intent intent) {
if (intent == null || TextUtils.isEmpty(intent.getAction())) {
return;
}
String extra = intent.getStringExtra(EXTRA);
if (EXTRA_PLAY.equals(extra)) {
if (AudioPlayer.getInstance().getStatus() == ManagedMediaPlayer.Status.STARTED) {
AudioPlayer.getInstance().pause();
} else if (AudioPlayer.getInstance().getStatus() == ManagedMediaPlayer.Status.PAUSED){
AudioPlayer.getInstance().resume();
}
} else if (EXTRA_NEXT.equals(extra)){
AudioPlayer.getInstance().next();
}
}
}
8、前臺服務(wù)
使用前臺服務(wù)開始播放音頻
public class PlayerService extends Service {
private static String ACTION_START = "ACTION_START";
private static String ACTION_PREVIOUS = "ACTION_PREVIOUS";
private static String ACTION_NEXT = "ACTION_NEXT";
private static String ACTION_GONE = "ACTION_GONE";
private static String ACTION_STOP = "ACTION_STOP";
public static void startPlayerService() {
Intent intent = new Intent(MyApplication.getContext(), PlayerService.class);
intent.setAction(ACTION_START);
MyApplication.getContext().startService(intent);
}
public static void playerPreviousService() {
Intent intent = new Intent(MyApplication.getContext(), PlayerService.class);
intent.setAction(ACTION_PREVIOUS);
MyApplication.getContext().startService(intent);
}
public static void playerNextService() {
Intent intent = new Intent(MyApplication.getContext(), PlayerService.class);
intent.setAction(ACTION_NEXT);
MyApplication.getContext().startService(intent);
}
public static void stopPlayerService() {
Intent intent = new Intent(MyApplication.getContext(), PlayerService.class);
MyApplication.getContext().stopService(intent);
}
@Override
public void onCreate() {
super.onCreate();
// 開始前臺服務(wù)
Notifier.getInstance().init(this);
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null && intent.getAction() != null) {
if (ACTION_START.equals(intent.getAction())) {
AudioPlayer.getInstance().play ();
} else if (ACTION_PREVIOUS.equals(intent.getAction())) {
AudioPlayer.getInstance().previous();
} else if (ACTION_NEXT.equals(intent.getAction())) {
AudioPlayer.getInstance().next();
}
}
return START_NOT_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
AudioPlayer.getInstance().release();
Notifier.getInstance().stopForeground();
}
}
9、開始播放
傳入播放列表，并開始服務(wù)即可播放
AudioPlayer.getInstance().setQueueAndIndex(list, 0);
PlayerService.startPlayerService();
