Android 使用MediaPlayer播放網路音訊
阿新 • • 發佈：2019-01-03
一、前言
MediaPlayer是Android自帶的一個多媒體播放類，可以播放音視訊流或者本地音視訊檔案。MediaPlayer方法的呼叫需要在一定的狀態下，下圖是一個MediaPlayer物件被支援的播放控制操作驅動的宣告週期和狀態。其中，橢圓代表MediaPlayer可能駐留的狀態，弧線表示驅動MediaPlayer在各個狀態之間遷移的播放控制操作。這裡有兩種型別的弧線。由單箭頭開始的弧線代表同步方法呼叫，而以雙箭頭開頭的弧線代表非同步方法呼叫。圖片介紹來源於官方文。
詳細介紹可通過Android – 多媒體播放之MediaPlayer基礎簡介瞭解更多
二、播放網路音訊
現在寫一個支援本地快取的網路音訊播放器,並添加了喚醒鎖、WiFi鎖和音訊焦點等功能。
1、自定義MediaPlayer
直接通過MediaPlayer獲取播放狀態有時不夠準確，所以自定義ManagedMediaPlayer繼承MediaPlayer，拓展MediaPlayer的功能，控制播放狀態
public class ManagedMediaPlayer extends MediaPlayer implements MediaPlayer.OnCompletionListener {
public enum Status {
IDLE, INITIALIZED, STARTED, PAUSED, STOPPED, COMPLETED
}
private 2、喚醒鎖、WiFi鎖
app在長時間後臺執行時，手機有可能會進入休眠，這是CUP和WiFi可能會停止執行，影響到app的正常執行，所以我們需要加入喚醒鎖和WiFi鎖保證我們在後臺長時間播放音訊的穩定。
初始化時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();在暫定和釋放資源的時候關閉WiFi鎖
// 關閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}3、音訊焦點
Android系統是一個多工作業系統，因此同一時刻允許許多工同時工作。但是這對音訊類應用來說是個挑戰，因為如果多個音訊同時播放的話，很多情況下使用者體驗會相當的差。當你需要播放音樂或者傳送一個通知的時候，你可以去要求獲得音訊焦點。一旦獲得，就可以自由的使用音訊輸出裝置。但是同時它也在時時刻刻的監聽著音訊焦點的變化。當音訊焦點變化時，你需要去合適的處理你的音訊輸出。
自定義AudioFocusManager實現音訊焦點變化監聽
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) {
// 通話結束，恢復播放
AudioPlayer.getInstance().resume();
}
// 恢復音量
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'
}自定義快取檔案命名規則
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;
}
}建立單例的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經過HttpProxyCacheServer轉化就可以了，AndroidVideoCache會處理快取
String url = "XXXXXXXXXXX";
HttpProxyCacheServer proxy = HttpProxyCacheUtil.getAudioProxy()
url = proxy.getProxyUrl(url);5、UI響應
監聽播放時不同的狀態，並通過廣播的形式通知UI做出響應。
建立一個基類的BasePlayReceiver，接收初始化資訊完成、資源準備完成、資源播放完成、播放狀態改變、緩衝進度和播放錯誤等廣播
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();
/**
* 播放狀態的改變
*/
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，實現其中的方法並動態註冊即可。
6、播放控制類
新建單例的音訊播放控制類AudioPlayer，方便對音訊進行控制，並在操作音訊之前都做了狀態判斷，儘可能的減少錯誤的發生。在AudioPlayer中可設定播放模式（順序、列表迴圈、隨機和單曲迴圈），播放，暫停，上下曲，seekTo，停止,獲取播放總時間和獲取當前播放進度等功能，並儲存全域性的播放列表和當前播放的音訊，方便獲取相關資訊。
public class AudioPlayer implements MediaPlayer.OnCompletionListener, MediaPlayer.OnPreparedListener, MediaPlayer.OnBufferingUpdateListener, MediaPlayer.OnErrorListener {
private static final String TAG = "AudioPlayer";
/**
* 播放方式
*/
public enum PlayMode {
/**
* 順序
*/
ORDER,
/**
* 列表迴圈
*/
LOOP,
/**
* 隨機
*/
RANDOM,
/**
* 單曲迴圈
*/
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;
}
// 更新播放器狀態
mMediaPlayer.reset();
nowPlaying = source;
// 更新Notification
Notifier.getInstance().showPlayInfo(source);
// 向MainActivity傳送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 傳送初始化資源資訊的廣告
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傳送EventBus
EventBus.getDefault().post(new MainActivityEvent());
// 傳送播放狀態的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
}
public void pause() {
if (getStatus() == ManagedMediaPlayer.Status.STARTED) {
mMediaPlayer.pause();
// 關閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}
// 傳送播放狀態的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
// 更新notification
Notifier.getInstance().showPlayInfo(nowPlaying);
// 向MainActivity傳送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();
// 傳送播放狀態的廣播
BasePlayReceiver.sendBroadcastPlayStatus(MyApplication.getContext());
// 更新notification
Notifier.getInstance().showPlayInfo(nowPlaying);
// 向MainActivity傳送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();
}
// 關閉wifi鎖
if (wifiLock.isHeld()) {
wifiLock.release();
}
wifiLock = null;
audioFocusManager = null;
proxy = null;
// 向MainActivity傳送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、通知欄
建立通知欄
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);
// 前臺服務
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.getLayo